Программирование GPU (NVIDIA CUDA)

1. КурносовМихаил Георгиевич
E-mail: mkurnosov@gmail.com
WWW: www.mkurnosov.net
Курс “Высокопроизводительные вычислительные системы”
Сибирский государственный университет телекоммуникаций и информатики (Новосибирск)
Осенний семестр, 2014
Лекция 9Программирование GPU

2. Graphics Processing Unit (GPU) –графический процессор, специализированный многопроцессорный ускоритель с общей памятью
Большая часть площади чипа занята элементарными ALU/FPU/Load/Store модулями
Устройство управления (Control unit) относительно простое по сравнению с CPU
NVIDIA GeForce GTX 780 (Kepler, 2304 cores, GDDR5 3 GB)
AMD Radeon HD 8970(2048 cores, GDDR5 3 GB)
GPU –Graphics Processing Unit

3. Гибридные вычислительные узлы
Несколько GPU
CPU управляет GPU через драйвер
Узкое место – передача данных между памятью CPU иGPU
GPU не является bootable-устройством
74 системы из Top500 (Nov. 2014) оснащены ускорителями (NVIDIA, ATI, Intel Xeon Phi, PEZY SC )
CPU1
Core1
Core2
Core3
Core4
GPU1
Cores
GPU Memory
Memory (DDR3)
Memory (DDR3)
QPI
I/O Hub
QPI
QPI
PCI Express Gen. 2
CPU1
Core1
Core2
Core3
Core4
GPU1
Cores
GPU Memory

4. Кластер Jet
Три узла с GPU(CUDA, MPI + CUDA):
cngpu1 –NVIDIA GeForce GTX 680
cngpu2 –2 x NVIDIA GeForce 210
cngpu3 –NVIDIA GeForce GT 630
http://cpct.sibsutis.ru/index.php/Main/CUDAGTX680

5. NVIDIA CUDA
5
NVIDIA CUDA –программно-аппаратная платформа для организации параллельных вычислений на графических процессорах (Graphic processing unit –GPU)
http://developer.nvidia.com/cuda
NVIDIA CUDASDK:
oархитектура виртуальной машиныCUDA
oкомпиляторC/C++
oдрайвер GPU
ОС: GNU/Linux, Apple Mac OS X, Microsoft Windows
2014–CUDA 6.5 (+ 64-bit ARM, Unified memory, Multi-GPU)
2006 –CUDA 1.0

6. Архитектура NVIDIA CUDA
6
CUDA C/C++/Fortran Source
CUDA C/C++/Fortran Compiler
(NVIDIA nvcc, PGI pgfortran)
PTX (Parallel Thread Execution)
(NVIDA GPU assembly language)
GPU Driver (JIT compiler)
GPU binary code
Host (CPU)
Device (GPU)
CPU Code

7. Архитектура NVIDIA CUDA
7
NVIDIA C/C++ Compiler (nvcc) –компилятор c расширений языков C/C++ (основан на LLVM), генерирует код для CPU и GPU
NVIDA PTX Assembler(ptxas)
Набор команд PTX развивается: PTX ISA 3.2 (2013), PTX ISA 3.1 (2012), PTX ISA 4.1 (2014)
Архитектуры NVIDIA CUDA
oNVIDIA Tesla (2007)
oNVIDIA Fermi (GeForce 400 Series, 2010)
oNVIDIA Kepler(GeForce 600 Series, 2012)
oNVIDIA Maxwell (GeForce 700 Series, 2014)
http://docs.nvidia.com/cuda/parallel-thread-execution/index.html

8. Гетерогенные вычислительные узлы
8
CPU1
Core1
Core2
Core3
Core4
GPU1
Cores
GPU Memory
Memory (DDR3)
Memory (DDR3)
QPI
I/O Hub
QPI
QPI
PCI Express Gen. 2
CPU1
Core1
Core2
Core3
Core4
GPU1
Cores
GPU Memory

9. Гетерогенные вычислительные узлы
9
NVIDIA Tesla K10 (2 GPU)
Процессорные ядра: 2 GPU NVIDIA GK104(2 x 1536 ядер)
Архитектура: NVIDIA Kepler
RAM: 8GB GDDR5
PCI Express 3.0

10. Архитектура NVIDIA Kepler(GK110)
10
15 SMX –streaming multiprocessor(возможны конфигурации с 13 и 14 SMX)
6 контроллеров памяти (64-бит)
Интерфейс подключения к хосту PCI Express 3.0

11. Архитектура NVIDIA Kepler(GK110)
11

12. Архитектура NVIDIA Kepler(GK110)
12
SMX – streaming multiprocessor

13. АрхитектураSMX(GK110)
13
192 ядра для выполнения операций с одинарной точностью (single precision float, integer)
64 модуля двойной точности (double precision, FMA)
32 модуля специальных функций (SFU)
32 модулячтения/записи (LD/ST)
4 планировщика потоков (warp schedulers)

14. АрхитектураSMX(GK110)
14

15. Warp scheduler (GK110)
15
Планировщик организует потоки в группы по 32 (warps)
Потоки группы выполняются одновременно
Каждый такт потоки группы (warp) выполняют две независимые инструкции (допустимо совмещение инструкций double и float)

16. Warp scheduler (GK110)
16

17. Организация памяти Kepler(GK110)
17
Каждый SMX имеет 64KB памяти:
o48KB shared + 16KB L1 cache
o16KB shared + 48KB L1 cache
L2 Cache1536KB – общий для всех SMX
Global Memory 8GB

18. Архитектура NVIDIA Kepler(GK110)
18
FERMI
GF100
FERMI
GF104
KEPLER
GK104
KEPLER
GK110
Compute Capability
2.0
2.1
3.0
3.5
Threads / Warp
32
32
32
32
Max Warps / Multiprocessor
48
48
64
64
Max Thread Blocks / Multiprocessor
8
8
16
16
Max Threads / Thread Block
1024
1024
1024
1024
32‐bit Registers / Multiprocessor
32768
32768
65536
65536
Max Registers / Thread
63
63
63
255
Max X Grid Dimension
2^16‐1
2^16‐1
2^32‐1
2^32‐1
Hyper‐Q
No
No
No
Yes
Dynamic Parallelism
No
No
No
Yes

19. NVIDIA Maxwell (2014)
19
NVIDIA Maxwell = GPU Cores + ARM Core
Интегрированное ядро ARM (64 бит, проект Denver)
oвозможность загрузки операционной системы на GPU
oподдержка унифицированной виртуальной памяти (device ←→ host)

20. Основные понятия CUDA
20
Хост (host)–узел с CPUи его память
Устройство (device) –графический процессор и его память
Ядро (kernel)–это фрагмент программы, предназначенный для выполнения на GPU
Пользователь самостоятельно запускает с CPU ядра на GPU
Перед выполнением ядра пользователь копирует данные из памяти хоста в память GPU
После выполнения ядра пользователь копирует данные из памяти GPU в память хоста

21. Основные понятия CUDA
21
CPU (Host)
GPU (Device)
void kernelA()
{
/* Code */
}
void kernelB()
{
/* Code */
}
/* Serial code */
/* Serial code */
/* Serial code */
kernelA()
kernelB()

22. Выполнение CUDA-программы
22
CPU (Host)
CPU
Memory
PCI Express
GPU (Device)
Memory
Копирование данных из памяти хоста в память GPU

23. Выполнение CUDA-программы
23
CPU (Host)
CPU
Memory
PCI Express
GPU (Device)
Memory
Копирование данных из памяти хоста в память GPU
Загрузка и выполнение ядра (kernel) в GPU

24. Выполнение CUDA-программы
24
CPU (Host)
CPU
Memory
PCI Express
GPU (Device)
Memory
Копирование данных из памяти хоста в память GPU
Загрузка и выполнение ядра (kernel) в GPU
Копирование данных из памяти GPUв память хоста

25. CUDA HelloWorld!
25
#include <stdio.h>
__global__ voidmykernel()
{
/* Parallel GPU code (kernel) */
}
intmain()
{
mykernel<<<1, 1>>>();
return0;
}

26. CUDA HelloWorld!
26
$ nvcc-c -o prog.o./prog.cu
$ g++ ./prog.o–o prog-L/opt/cuda-5.5/lib64
-lcudart

27. Вычислительные ядра (kernels)
27
Спецификатор __global__ сообщаеткомпилятору, что функция предназначена для выполнения на GPU
Компилятор nvccразделяет исходный код– ядра компилируются nvcc, а остальной код системным компилятором (gcc, cl, …)
Тройные угловые скобки “<<< >>>”сообщают о вызове ядра на GPUи количестве требуемых потоков
Вызов ядра (kernel) не блокирует выполнение потока на CPU
Функция cudaThreadSynchronize()позволяет реализовать ожидание завершения ядра

28. Вычислительные потоки (threads)
28
Номер потока (thread index)–это трехкомпонентный вектор (координатыпотока)
Потоки логически сгруппированы в одномерный, двухмерный или трёхмерный блок(thread block)
Количество потоков в блоке ограничено(в Kepler1024)
Блоки распределяются по потоковым мультипроцессорам SMX
Предопределенные переменные
othreadIdx.{x, y, z}–номер потока
oblockDim.{x, y, z}–размерность блока
Thread Block
Thread
Thread
Thread
Thread
Thread
Thread

29. Вычислительные потоки (threads)
29
Блоки группируются одно-двух-и трехмерную сетку(grid)
Блоки распределяются по потоковым мультипроцессорам SMX (в Kepler15 SMX)
Предопределенные переменные
oblockIdx.{x, y, z} –номер блока потока
ogridDim.{x, y, z} –размерность сетки

30. Вычислительные потоки (threads)
30
Grid of thread blocks
Thread Block
Thread
Thread
Thread
Thread
Thread
Thread
Thread Block
Thread
Thread
Thread
Thread
Thread
Thread
Thread Block
Thread
Thread
Thread
Thread
Thread
Thread
Thread Block
Thread
Thread
Thread
Thread
Thread
Thread
Thread Block
Thread
Thread
Thread
Thread
Thread
Thread
Thread Block
Thread
Thread
Thread
Thread
Thread
Thread
gridDim.y
gridDim.x
blockDim.x
blockDim.z
blockDim.y

31. CUDA Program
Выполнение CUDA-программы
31
Block 0
Block 1
Block 2
Block 3
Block 4
Block 5
GPU 1
Block 0
Block 1
Block 2
Block 3
Block 4
Block 5
SMX 1
SMX 2
GPU 2
Block 0
Block 1
Block 2
Block 3
Block 4
Block 5
SMX 1
SMX 2
SMX 3

32. Пример: сложение векторов
32
voidvecadd(float*a, float*b, float*c, intn)
{
inti;
for(i = 0; i < n; i++) {
c[i] = a[i] + b[i];
}
}

33. Пример: сложение векторов
33
intmain()
{
inti, n = 100;
float*a, *b, *c;
float*deva, *devb, *devc;
a = (float*)malloc(sizeof(float) * n);
b = (float*)malloc(sizeof(float) * n);
c = (float*)malloc(sizeof(float) * n);
for(i = 0; i < n; i++) {
a[i] = 2.0;
b[i] = 4.0;
}

34. Пример: сложение векторов
34
// Выделяем память на GPU
cudaMalloc((void **)&deva, sizeof(float) * n);
cudaMalloc((void **)&devb, sizeof(float) * n);
cudaMalloc((void **)&devc, sizeof(float) * n);
// Копируем из памяти узла в память GPU
cudaMemcpy(deva, a, sizeof(float) * n,
cudaMemcpyHostToDevice);
cudaMemcpy(devb, b, sizeof(float) * n,
cudaMemcpyHostToDevice);
vecadd_gpu<<<1, n>>>(deva, devb, devc);
cudaMemcpy(c, devc, sizeof(float) * n,
cudaMemcpyDeviceToHost);
cudaFree(deva);cudaFree(devb);cudaFree(devc);
free(a);free(b);free(c);
return0;
}

35. Пример: сложение векторов
35
__global__ voidvecadd_gpu(float*a, float*b, float*c)
{
// Каждый поток обрабатывает один элемент
inti = threadIdx.x;
c[i] = a[i] + b[i];
}
Запускается один блок из nпотоков (n<= 1024)
vecadd_gpu<<<1, n>>>(deva, devb, devc);
Каждый поток вычисляет один элемент массива c
Thread Block
Thread0
Thread1
Threadn-1
…

36. Пример: сложение векторов
36
Сложение векторов с количеством элементов > 256
intthreadsPerBlock= 256; /* Device specific */
intblocksPerGrid= (n + threadsPerBlock-1) /
threadsPerBlock;
vecadd_gpu<<<blocksPerGrid, threadsPerBlock>>>(deva,
devb, devc, n);
Будет запущена группа блоков, в каждом блоке по фиксированному количеству потоков
Потоков может быть больше чем элементов в массиве

37. Пример: сложение векторов
37
__global__ voidvecadd_gpu(float*a, float*b,
float*c, intn)
{
inti = threadIdx.x+ blockIdx.x* blockDim.x;
if(i < n)
c[i] = a[i] + b[i];
}
Thread Block0
Thread0
Thread1
Thread…
…
Thread Block1
Thread0
Thread1
Thread …
…
Thread Block2
Thread0
Thread1
Thread…
…
Thread Block3
Thread0
Thread1
Thread …
…

38. Двухмерный блок потоков
38
dim3threadsPerBlock(N, N);
matrix<<<1, threadsPerBlock>>>(A, B, C);
Двухмерный блок потоков (threadIdx.x, threadIdx.y)

39. Информация о GPU
39
cudaSetDevice(0);
cudaDevicePropdeviceProp;
cudaGetDeviceProperties(&deviceProp, 0);
/*
* deviceProp.maxThreadsPerBlock
* deviceProp.warpSize
* devProp.totalGlobalMem
* ...
*/

40. NVIDIA GeForce GTS 250
40
CUDA Device Query (Runtime API) version (CUDART static linking)
Device 0: "GeForce GTS 250"
CUDA Driver Version: 3.20
CUDA Runtime Version: 3.20
CUDA Capability Major/Minor version number: 1.1
Total amount of global memory: 1073020928 bytes
Multiprocessors x Cores/MP = Cores: 16 (MP) x 8 (Cores/MP) =
128 (Cores)
Total amount of constant memory: 65536 bytes
Total amount of shared memory per block: 16384 bytes
Total number of registers available per block: 8192
Warp size: 32
Maximum number of threads per block: 512
Maximum sizes of each dimension of a block: 512 x 512 x 64
Maximum sizes of each dimension of a grid: 65535 x 65535 x 1
Maximum memory pitch: 2147483647 bytes
Texture alignment: 256 bytes
Clock rate: 1.91 GHz
Concurrent copy and execution: Yes
Run time limit on kernels: Yes
Support host page-locked memory mapping: Yes
Compute mode: Default (multiple host
threads can use this device simultaneously)
Concurrent kernel execution: No
Device has ECC support enabled: No

41. Иерархия памяти
41
NVidia GeForce GTS 250
Global memory: 1GB
Shared mem. per block: 16KB
Constant memory: 64KB
Registers per block: 8192

42. Data race
42
__global__ voidrace(int* x)
{
inti= threadIdx.x+ blockDim.x* blockIdx.x;
*x = *x + 1; // Data race
}
intmain()
{
intx;
// ...
race<<<1, 128>>>(d_x);
// ...
return0;
}

43. CUDA Atomics
43
CUDA предоставляет API атомарных операций:
atomicAdd, atomicSub, atomicInc, atomicDec
atomicMax, atomicMin
atomicExch
atomicCAS
atomicAnd, atomicOr, atomicXor
atomicOP(a,b)
{
t1 = *a; // read
t2 = t1 OPb; // modify
*a = t2;// write
returnt;
}

44. CUDA Atomics
44
__global__ voidrace(int* x)
{
inti= threadIdx.x+ blockDim.x* blockIdx.x;
int j = atomicAdd(x, 1); // j = *x; *x = j + i;
}
intmain()
{
intx;
// ...
race<<<1, 128>>>(d_x);
// ...
return0;
}

45. Умножение матриц
45
C = A * B
Результирующая матрица C разбивается на подматрицы размером 16x16элементов
Подматрицы параллельно вычисляются блоками потоков
Каждый элемент подматрицы вычисляется отдельным потоком (в блоке 16x16 = 256 потоков)
Количество потоков = количеству элементов в матрице C

46. intmain()
{
intblock_size= 16;
dim3dimsA(10 * block_size, 10 * block_size, 1);
dim3dimsB(20 * block_size, 10 * block_size, 1);
printf("A(%d,%d), B(%d,%d)n", dimsA.x, dimsA.y,
dimsB.x, dimsB.y);
unsignedintsize_A= dimsA.x* dimsA.y;
unsignedintmem_size_A= sizeof(float) * size_A;
float*h_A= (float *)malloc(mem_size_A);
unsignedintsize_B= dimsB.x* dimsB.y;
unsignedintmem_size_B= sizeof(float) * size_B;
float*h_B= (float *)malloc(mem_size_B);
dim3dimsC(dimsB.x, dimsA.y, 1);
unsigned intmem_size_C= dimsC.x* dimsC.y*
sizeof(float);
float*h_C= (float *) malloc(mem_size_C);
Умножение матриц
46

47. Умножение матриц
47
constfloatvalB= 0.01f;
constantInit(h_A, size_A, 1.0f);
constantInit(h_B, size_B, 0.01f);
float*d_A, *d_B, *d_C;
cudaMalloc((void **) &d_A, mem_size_A);
cudaMalloc((void **) &d_B, mem_size_B);
cudaMalloc((void **) &d_C, mem_size_C);
cudaMemcpy(d_A, h_A, mem_size_A,
cudaMemcpyHostToDevice);
cudaMemcpy(d_B, h_B, mem_size_B,
cudaMemcpyHostToDevice);

48. Умножение матриц
48
dim3threads(block_size, block_size);
dim3grid(dimsB.x/ threads.x,
dimsA.y/ threads.y);
matmul_gpu<16><<<grid, threads>>>(d_C, d_A,
d_B, dimsA.x, dimsB.x);
cudaDeviceSynchronize();
cudaMemcpy(h_C, d_C, mem_size_C,
cudaMemcpyDeviceToHost);

49. Умножение матриц
49
free(h_A);
free(h_B);
free(h_C);
cudaFree(d_A);
cudaFree(d_B);
cudaFree(d_C);
return0;
} /* main */

50. Умножение матриц
50
template<intBLOCK_SIZE>
__global__ voidmatmul_gpu(float*C, float*A,
float*B, intwA, intwB)
{
intbx= blockIdx.x;
intby = blockIdx.y;
inttx= threadIdx.x;
intty= threadIdx.y;
intaBegin= wA* BLOCK_SIZE * by;
intaEnd= aBegin+ wA-1;
intaStep= BLOCK_SIZE;
intbBegin= BLOCK_SIZE * bx;
intbStep= BLOCK_SIZE * wB;
floatCsub= 0;

51. Умножение матриц
51
for(inta = aBegin, b = bBegin; a <= aEnd;
a += aStep, b += bStep)
{
// sub-matrix of A
__shared__ floatAs[BLOCK_SIZE][BLOCK_SIZE];
// sub-matrix of B
__shared__ floatBs[BLOCK_SIZE][BLOCK_SIZE];
// Load from device memory to shared memory
As[ty][tx] = A[a + wA* ty+ tx];
Bs[ty][tx] = B[b + wB* ty+ tx];
// Synchronize (wait for loading matrices)
__syncthreads();

52. Умножение матриц
52
// Multiply the two matrices
#pragma unroll
for(intk = 0; k < BLOCK_SIZE; ++k) {
Csub+= As[ty][k] * Bs[k][tx];
}
__syncthreads();
} /* for aBegin... */
// Write the block sub-matrix to device memory;
intc = wB* BLOCK_SIZE * by + BLOCK_SIZE * bx;
C[c + wB* ty+ tx] = Csub;
}

53. Reduction
53
O(log2n)
Mark Harris. OptimizingParallelReductioninCUDA // http://www.cuvilib.com/Reduction.pdf

54. Reduction v1
54
Условный оператор ifвнутри цикла приводит к сильному ветвлению
Можно перераспределить данные и операции по нитям

55. Reduction v2
55
Количество ветвлений сокращено
Большое число конфликтов банков при обращении к разделяемой памяти

56. Dynamic parallelism (CUDA 5.0)
56
__global__ ChildKernel(void* data)
{
// Operate on data
}
__global__ ParentKernel(void *data)
{
ChildKernel<<<16, 1>>>(data);
}
// In Host Code
ParentKernel<<<256, 64>>(data);

57. Dynamic parallelism (CUDA 5.0)
57
__global__ RecursiveKernel(void* data)
{
if(continueRecursion== true)
RecursiveKernel<<<64, 16>>>(data);
}

58. Dynamic parallelism (CUDA 5.0)
58

59. Литература
59
CUDA by Example// http://developer.download.nvidia.com/books/cuda-by- example/cuda-by-example-sample.pdf
Джейсон Сандерс, Эдвард Кэндрот. Технология CUDA в примерах. ДМК Пресс, 2011 г.
А. В. Боресков, А. А. Харламов. Основы работы с технологией CUDA. М.:ДМК, 2010 г. http://www.nvidia.ru/object/cuda-parallel-computing-books-ru.html