CyberConnect2에서는 2013년부터 DirectX11세대용 멀티플랫폼엔진 개발을 시작하였으며, 제작 시 발생하였던 문제점을 DirectX9와의 차이점을 바탕으로 공유하고자 합니다.
이 세션은 DirectX11의 개발이 처음이거나 관심 있으신 분을 대상으로 합니다. Tessellation 이나 OIT와 같은 최신기술은 다루지 않으므로 주의하시기 바랍니다.
한 학기동안 개인적으로 공부한 내용을 토대로 수업시간에 발표한 내용입니다.
혹시라도 올바르지 않은 내용이 있다면 코멘트로 알려주시면 감사하겠습니다 :)
this was announced at my presentation class and it's based on study result during a semester.
----------------------------------------------
청강문화산업대학교 게임스쿨
201713058 권필성
Chungkang College of Cultural Industries, Game School
201713058 Kwon Pil Seong AKA. ODESSA
CyberConnect2에서는 2013년부터 DirectX11세대용 멀티플랫폼엔진 개발을 시작하였으며, 제작 시 발생하였던 문제점을 DirectX9와의 차이점을 바탕으로 공유하고자 합니다.
이 세션은 DirectX11의 개발이 처음이거나 관심 있으신 분을 대상으로 합니다. Tessellation 이나 OIT와 같은 최신기술은 다루지 않으므로 주의하시기 바랍니다.
한 학기동안 개인적으로 공부한 내용을 토대로 수업시간에 발표한 내용입니다.
혹시라도 올바르지 않은 내용이 있다면 코멘트로 알려주시면 감사하겠습니다 :)
this was announced at my presentation class and it's based on study result during a semester.
----------------------------------------------
청강문화산업대학교 게임스쿨
201713058 권필성
Chungkang College of Cultural Industries, Game School
201713058 Kwon Pil Seong AKA. ODESSA
오늘날 멀티코어 프로세서 세상은 이기종 컴퓨팅 환경이 대부분이라 해도 과언이 아니다.
병렬 컴퓨팅은 비약적인 속도 향상과 전력 소비 감소라는 장점이 있지만 사용하기가 까다롭고 특히 다양한 아키텍처로 이루어진 이기종 컴퓨팅 환경에서는 소프트웨어 개발이 더욱 어려워진다.
이 프리젠테이션에서는 이기종 컴퓨팅 환경에서의 병렬 처리를 위한 프로그래밍 언어를 소개하고 OpenCV와 같은 영상처리 라이브러리에서의 활용 예시를 보여준다
프로그래밍 언어의 F1머신 C++을 타고 Windows 10 UWP 앱 개발의 세계로~YEONG-CHEON YOU
Windows 10의 UWP 앱을 개발하면 모든 Windows 10 디바이스에서 앱을 작동할 수 있습니다.
이 UWP 앱을 C++로 개발할 수 있습니다. C++로 앱을 개발하면 크로스 플랫폼 지원의 유리함, 기존 코드의 재활용, 성능향상 등의 이점이 있습니다. 본 세션에서는 몇 가지 예를 들어 C++로 UWP 앱을 개발하는 방법을 소개하며 특히 win32와 C++을 사용하던 개발자가 쉽게 UWP 앱 개발에 적응할 수 있도록 돕습니다.
Steered response power phase transform(SRP-PHAT)은 음원 방향 추정을 위해 널리 사용되는 알고리즘이다. SRP-PHAT는 매우 많은 수의 후보 좌표를 조사해야만 하므로 기존 SRP-PHAT들은 실시간에 실행되지 못할 수도 있었다. 이 문제를 극복하기 위해, SRP-PHAT를 graphics processing units(GPUs) 기반으로 병렬화하는 시도가 있었다. 그러나, 그 방법들은 on-chip 메모리를 모두 쓰지 못하여 GPUs의 최대 연산 능력을 활용할 수 없었다. 이 발표에서 우리는 SRP-PHAT의 GPU 기반 병렬 알고리즘들을 주파수 영역과 시간 영역의 두 버전으로 제안한다. 제안된 알고리즘들은 SRP-PHAT의 메모리 접근 패턴을 최적화하고 on-chip 메모리를 공격적으로 사용한다. 결과적으로 제안된 방법들은 CPU 기반 알고리즘들에 비해 주파수 영역에서 1,276 배 그리고 시간 영역에서 80 배의 속도 향상을, 그리고 기존 GPU 기반 알고리즘들에 비해 주파수 영역에서 1.5 배 그리고 시간 영역에서 6 배의 속도 향상을 보였다.
오늘날 멀티코어 프로세서 세상은 이기종 컴퓨팅 환경이 대부분이라 해도 과언이 아니다.
병렬 컴퓨팅은 비약적인 속도 향상과 전력 소비 감소라는 장점이 있지만 사용하기가 까다롭고 특히 다양한 아키텍처로 이루어진 이기종 컴퓨팅 환경에서는 소프트웨어 개발이 더욱 어려워진다.
이 프리젠테이션에서는 이기종 컴퓨팅 환경에서의 병렬 처리를 위한 프로그래밍 언어를 소개하고 OpenCV와 같은 영상처리 라이브러리에서의 활용 예시를 보여준다
프로그래밍 언어의 F1머신 C++을 타고 Windows 10 UWP 앱 개발의 세계로~YEONG-CHEON YOU
Windows 10의 UWP 앱을 개발하면 모든 Windows 10 디바이스에서 앱을 작동할 수 있습니다.
이 UWP 앱을 C++로 개발할 수 있습니다. C++로 앱을 개발하면 크로스 플랫폼 지원의 유리함, 기존 코드의 재활용, 성능향상 등의 이점이 있습니다. 본 세션에서는 몇 가지 예를 들어 C++로 UWP 앱을 개발하는 방법을 소개하며 특히 win32와 C++을 사용하던 개발자가 쉽게 UWP 앱 개발에 적응할 수 있도록 돕습니다.
Steered response power phase transform(SRP-PHAT)은 음원 방향 추정을 위해 널리 사용되는 알고리즘이다. SRP-PHAT는 매우 많은 수의 후보 좌표를 조사해야만 하므로 기존 SRP-PHAT들은 실시간에 실행되지 못할 수도 있었다. 이 문제를 극복하기 위해, SRP-PHAT를 graphics processing units(GPUs) 기반으로 병렬화하는 시도가 있었다. 그러나, 그 방법들은 on-chip 메모리를 모두 쓰지 못하여 GPUs의 최대 연산 능력을 활용할 수 없었다. 이 발표에서 우리는 SRP-PHAT의 GPU 기반 병렬 알고리즘들을 주파수 영역과 시간 영역의 두 버전으로 제안한다. 제안된 알고리즘들은 SRP-PHAT의 메모리 접근 패턴을 최적화하고 on-chip 메모리를 공격적으로 사용한다. 결과적으로 제안된 방법들은 CPU 기반 알고리즘들에 비해 주파수 영역에서 1,276 배 그리고 시간 영역에서 80 배의 속도 향상을, 그리고 기존 GPU 기반 알고리즘들에 비해 주파수 영역에서 1.5 배 그리고 시간 영역에서 6 배의 속도 향상을 보였다.
102. void MatrixMultSimple(vector<float>& vC, const vector<float>& vA, const vector<float>& vB, int M, int N, int W )
{
array_view<const float,2> a(M, W, vA), b(W, N, vB);
array_view<writeonly<float>,2> c(M,N,vC);
parallel_for_each(c.grid,
[=] (index<2> idx) restrict(direct3d) {
int row = idx[0]; int col = idx[1];
float sum = 0.0f;
for(int k = 0; k < W; k++)
sum += a(row, k) * b(k, col);
c[idx] = sum;
} );
}
103. void MatrixMultTiled(vector<float>& vC, const vector<float>& vA, const vector<float>& vB, int M, int N, int W )
{
static const int TS = 16;
array_view<const float,2> a(M, W, vA), b(W, N, vB);
array_view<writeonly<float>,2> c(M,N,vC);
parallel_for_each(c.grid.tile< TS, TS >(),
[=] (tiled_index< TS, TS> t_idx) restrict(direct3d) {
int row = t_idx.local[0]; int col = t_idx.local[1];
float sum = 0.0f;
for (int i = 0; i < W; i += TS) {
tile_static float locA[TS][TS], locB[TS][TS];
locA[row][col] = a(t_idx.global[0], col + i);
static const int TS = 16;
locB[row][col] = b(row + i, t_idx.global[1]);
t_idx.barrier.wait();
for (int k = 0; k < TS; k++)
sum += locA[row][k] * locB[k][col];
t_idx.barrier.wait();
}
c[t_idx.global] = sum;
} );
}
104. void MatrixMultTiled(vector<float>& vC, const vector<float>& vA, const vector<float>& vB, int M, int N, int W )
{
static const int TS = 16;
array_view<const float,2> a(M, W, vA), b(W, N, vB);
array_view<writeonly<float>,2> c(M,N,vC);
parallel_for_each(c.grid.tile< TS, TS >(),
[=] (tiled_index< TS, TS> t_idx) restrict(direct3d) {
int row = t_idx.local[0]; int col = t_idx.local[1];
float sum = 0.0f;
for (int i = 0; i < W; i += TS) {
tile_static float locA[TS][TS], locB[TS][TS];
locA[row][col] = a(t_idx.global[0], col + i);
parallel_for_each( c.grid.tile< TS, TS >(), … )
locB[row][col] = b(row + i, t_idx.global[1]);
t_idx.barrier.wait();
for (int k = 0; k < TS; k++)
sum += locA[row][k] * locB[k][col];
t_idx.barrier.wait();
}
c[t_idx.global] = sum;
} );
}
105. void MatrixMultTiled(vector<float>& vC, const vector<float>& vA, const vector<float>& vB, int M, int N, int W )
{
static const int TS = 16;
array_view<const float,2> a(M, W, vA), b(W, N, vB);
array_view<writeonly<float>,2> c(M,N,vC);
parallel_for_each(c.grid.tile< TS, TS >(),
[=] (tiled_index< TS, TS> t_idx) restrict(direct3d) {
int row = t_idx.local[0]; int col = t_idx.local[1];
float sum = 0.0f;
for (int i = 0; i < W; i += TS) {
tile_static float locA[TS][TS], locB[TS][TS];
locA[row][col] = a(t_idx.global[0], col + i);
locB[row][col] = b(row + i, t_idx.global[1]);
[=](tiled_index< TS, TS > t_idx )
t_idx.barrier.wait();
for (int k = 0; k < TS; k++)
sum += locA[row][k] * locB[k][col];
t_idx.barrier.wait();
}
c[t_idx.global] = sum;
} );
}
106. void MatrixMultTiled(vector<float>& vC, const vector<float>& vA, const vector<float>& vB, int M, int N, int W )
{
static const int TS = 16;
array_view<const float,2> a(M, W, vA), b(W, N, vB);
array_view<writeonly<float>,2> c(M,N,vC);
parallel_for_each(c.grid.tile< TS, TS >(),
[=] (tiled_index< TS, TS> t_idx) restrict(direct3d) {
int row = t_idx.local[0]; int col = t_idx.local[1];
float sum = 0.0f;
for (int i = 0; i < W; i += TS) {
tile_static float locA[TS][TS], locB[TS][TS];
locA[row][col] = a(t_idx.global[0], col + i);
locB[row][col] = b(row + i, t_idx.global[1]);
t_idx.barrier.wait();
for (int k = 0; k < TS; k++)
sum += locA[row][k] * locB[k][col];
tile_static_float locA[TS][TS], …
t_idx.barrier.wait();
}
c[t_idx.global] = sum;
}
} );
locA[row][col] = a( … );
107. void MatrixMultTiled(vector<float>& vC, const vector<float>& vA, const vector<float>& vB, int M, int N, int W )
{
static const int TS = 16;
array_view<const float,2> a(M, W, vA), b(W, N, vB);
array_view<writeonly<float>,2> c(M,N,vC);
parallel_for_each(c.grid.tile< TS, TS >(),
[=] (tiled_index< TS, TS> t_idx) restrict(direct3d) {
int row = t_idx.local[0]; int col = t_idx.local[1];
float sum = 0.0f;
for (int i = 0; i < W; i += TS) {
tile_static float locA[TS][TS], locB[TS][TS];
locA[row][col] = a(t_idx.global[0], col + i);
locB[row][col] = b(row + i, t_idx.global[1]);
t_idx.barrier.wait();
for (int k = 0; k < TS; k++)
sum += locA[row][k] * locB[k][col];
t_idx.barrier.wait();
t_idx.barrier.wait();
}
c[t_idx.global] = sum;
} );
}
108. void MatrixMultTiled(vector<float>& vC, const vector<float>& vA, const vector<float>& vB, int M, int N, int W )
{
static const int TS = 16;
array_view<const float,2> a(M, W, vA), b(W, N, vB);
array_view<writeonly<float>,2> c(M,N,vC);
parallel_for_each(c.grid.tile< TS, TS >(),
[=] (tiled_index< TS, TS> t_idx) restrict(direct3d) {
int row = t_idx.local[0]; int col = t_idx.local[1];
float sum = 0.0f;
for (int i = 0; i < W; i += TS) {
tile_static float locA[TS][TS], locB[TS][TS];
locA[row][col] = a(t_idx.global[0], col + i);
locB[row][col] = b(row + i, t_idx.global[1]);
t_idx.barrier.wait();
for (int k = 0; k < TS; k++)
sum += locA[row][k] * locB[k][col];
t_idx.barrier.wait();
}
c[t_idx.global] = sum;
}
} );
t_idx.barrier.wait();
109. void MatrixMultTiled(vector<float>& vC, const vector<float>& vA, const vector<float>& vB, int M, int N, int W )
{
static const int TS = 16;
array_view<const float,2> a(M, W, vA), b(W, N, vB);
array_view<writeonly<float>,2> c(M,N,vC);
parallel_for_each(c.grid.tile< TS, TS >(),
[=] (tiled_index< TS, TS> t_idx) restrict(direct3d) {
int row = t_idx.local[0]; int col = t_idx.local[1];
float sum = 0.0f;
for (int i = 0; i < W; i += TS) {
tile_static float locA[TS][TS], locB[TS][TS];
c[ t_idx.global ] = sum;
locA[row][col] = a(t_idx.global[0], col + i);
locB[row][col] = b(row + i, t_idx.global[1]);
t_idx.barrier.wait();
for (int k = 0; k < TS; k++)
sum += locA[row][k] * locB[k][col];
t_idx.barrier.wait();
}
c[t_idx.global] = sum;
} );
}
110. 일반 프로그래밍 보다
난이도가 높습니다.
하지만 Visual Studio 에서
완벽 지원할 것입니다.
( 디버깅 가능 )
