C++ AMP 실천 및 적용 전략

2. 3,100,000
Transistors

3. 1.4 Billion
Transistors
Ivy Bridge

4. 1971, Intel, 4004
4bits processor
740Khz(8 clock
cycle/instruction cycle)
2012, Intel, 80637
(Ivy Bridge)
64bits processor
4.1Ghz

7. How(Old Features)
Multithread
Programming
OpenMP PPL / TPL

8. How(VS2012 New Features)
Auto-
Vectorization
Auto-
Parallelization
C++ AMP

10. CPU
images source: AMD

12. performance
portability
productivity

13. void AddArrays(int n, int * pA, int * pB, int * pC)
{
for (int i=0; i<n; i++)
{
pC[i] = pA[i] + pB[i];
}
}
void AddArrays(int n, int * pA, int * pB, int * pC)
{
for (int i=0; i<n; i++)
{
pC[i] = pA[i] + pB[i];
}
}
#include <amp.h>
using namespace concurrency;
void AddArrays(int n, int * pA, int * pB, int * pC)
{
array_view<int,1> a(n, pA);
array_view<int,1> b(n, pB);
array_view<int,1> sum(n, pC);
parallel_for_each(
sum.extent,
[=](index<1> i) restrict(amp)
{
sum[i] = a[i] + b[i];
}
);
}

14. void AddArrays(int n, int * pA, int * pB, int * pC)
{
array_view<int,1> a(n, pA);
array_view<int,1> b(n, pB);
array_view<int,1> sum(n, pC);
parallel_for_each(
sum.extent,
[=](index<1> i) restrict(amp)
{
sum[i] = a[i] + b[i];
}
);
}
parallel_for_each:
execute the lambda on
the accelerator once per
thread
extent: the number
and shape of threads to
execute the lambda
index: the thread ID
that is running the
lambda, used to index
into data
restrict(amp): tells the compiler to
check that this code conforms to C++
AMP language restriction
array_view: wrap the data to operate
on the accelerator
array_view variables captured and associated
data copied to accelerator(on demand)

15. index<1> i(2); index<3> i(2,0,1);
extent<3> e(3,2,2);
index<2> i(0,2);
extent<2> e(3,4);extent<1> e(6);
N <= 128

16. vector<int> v(10);
extent<2> e(2,5);
array_view<int,2> a(e, v);
//above two lines can also be written
//array_view<int,2> a(2,5,v);
index<2> i(1,3);
int o = a[i]; // or a[i] = 16;
//or int o = a(1, 3);

17. 1. parallel_for_each(
2. e, // e is of type extent<N>
3. [ ](index<N> idx) restrict(amp)
{
// kernel code
}
1. );

20. • No
• recursion
• 'volatile'
• virtual functions
• pointers to functions
• pointers to member functions
• pointers in structs
• pointers to pointers
• bitfields
• No
• goto or labeled statements
• throw, try, catch
• globals or statics
• dynamic_cast or typeid
• asm declarations
• varargs
• unsupported types
• e.g. char, short, long double

21. double cos( double d ); // 1a: cpu code
double cos( double d ) restrict(amp); // 1b: amp code
double bar( double d ) restrict(cpu,amp); // 2 : common subset of both
void some_method(array_view<double,2>& c) {
parallel_for_each( c.extent, [=](index<2> idx) restrict(amp)
{
//…
double d0 = c[idx];
double d1 = bar(d0); // ok, bar restrictions include amp
double d2 = cos(d0); // ok, chooses amp overload
//…
});
}

22. void MatrixMultiplySerial( vector<float>& vC,
const vector<float>& vA,
const vector<float>& vB, int M, int N, int W )
{
for (int row = 0; row < M; row++) {
for (int col = 0; col < N; col++){
float sum = 0.0f;
for(int i = 0; i < W; i++)
sum += vA[row * W + i] * vB[i * N + col];
vC[row * N + col] = sum;
}
}
}
void MatrixMultiplyAMP( 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<float,2> c(M,N,vC);
c.discard_data();
parallel_for_each(c.extent,
[=](index<2> idx) restrict(amp) {
int row = idx[0]; int col = idx[1];
float sum = 0.0f;
for(int i = 0; i < W; i++)
sum += a(row, i) * b(i, col);
c[idx] = sum;
}
);
}

23. CPUs
System memory
GPUPCIe
GPU
GPU
GPU
Host Accelerator (e.g. discrete G

24. // enumerate all accelerators
vector<accelerator> accs = accelerator::get_all();
// choose one based on your criteria
accelerator acc = accs[0];
// launch a kernel on it
parallel_for_each(acc.default_view, my_extent, [=]…);

25. DEMO

27. vector<int> v(5);
iota(v.begin(), v.end(), 0);
array<int, 1> a(5, v.begin(), v.end());
parallel_for_each(a.extent, [&](index<1> idx)
restrict (amp)
{
a[idx] = a[idx] * 2;
});
copy(a, v.begin());
vector<int> v(5);
iota(v.begin(), v.end(), 0);
array_view<int, 1> av(5, v);
parallel_for_each(av.extent, [=](index<1> idx)
restrict (amp)
{
av[idx] = av[idx] * 2;
});
av.synchronize();

28. 1 accelerator_view acc_view = accelerator().default_view;
2
3 int a = 10;
4 std::vector<int> view_data(size);
5 array_view<int, 1> arr_view(size, view_data);
6 std::vector<int> arr_data(size);
7 array<int, 1> arr(size, arr_data.begin(),acc_view);
8

29. 9 // ‘arr_view’ copied by value
10 // ‘a’ copied by value.
11 // ‘arr’ already allocated on accelerator and copied by ref
12
13 parallel_for_each(
14 arr.extent,
15 [=,&arr](index<1> idx) restrict(amp)
16 {
17 arr[idx] = arr_view[idx] + a;
18 arr_view[idx]++;
19 });
20

30. 21 // ‘arr’ needs to be explictly copied back
22 copy(arr, arr_data.begin());
23
24 // ‘arr_view’ is synchronized back on first use
25 std::cout << arr_view[0] << std::endl;

31. 1. #include <amp.h>
2. #include <amp_math.h>
3. using namespace concurrency;
4. using namespace concurrency::fast_math;
// using namespace
concurrency::precise_math;
5. int main() {
6. float a = 2.2f, b = 3.5f;
7. float result = pow(a,b);
8. std::vector<float> v(1);
9. array_view<float> av(1,v);
10. parallel_for_each(av.extent, [=](index<1>
idx) restrict(amp)
11. {
12. av[idx] = pow(a,b);
13. });
14. }

38. DEMO