Programowanie procesorów graficznych GPGPU. Krzysztof Banaś Obliczenia równoległe 1

Transkrypt

1 Programowanie procesorów graficznych GPGPU Krzysztof Banaś Obliczenia równoległe 1

2 OpenCL projektowanie kerneli Przypomnienie: kernel program realizowany przez urządzenie OpenCL wątek (work item) rdzeń (processing element): zazwyczaj jeden wątek wykonywany jest przez jeden rdzeń grupa wątków (work group) jednostka obliczeniowa (compute unit): grupa wątków wykonuje obliczenia na jednej jednostce obliczeniowej grupa wątków powinna mieć więcej wątków niż rdzeni w jednostce obliczeniowej grupa dzielona jest na podgrupy, wavefronts/warps, wątków wykonywanych jednocześnie w modelu SIMD przestrzeń wątków urządzenie: wszystkie watki z przestrzeni realizują zlecony kernel na urządzeniu Krzysztof Banaś Obliczenia równoległe 2

3 Przestrzeń wątków Krzysztof Banaś Obliczenia równoległe 3

4 OpenCL projektowanie kerneli Przypomnienie: wielopoziomowa hierarchia pamięci: rejestry najszybsze zmienne lokalne (jeśli nie jest ich za dużo, register spilling) prywatne dla każdego wątku pamięć wspólna szybka zmienne (tablice) z atrybutem local wspólne dla wątków z jednej grupy roboczej pamięć globalna powolna zmienne lokalne nie mieszczące się w rejestrach zmienne (tablice) z atrybutem local» wspólne dla wszystkich wątków dodatkowe rodzaje pamięci: constant, texture Krzysztof Banaś Obliczenia równoległe 4

5 OpenCL model pamięci Krzysztof Banaś Obliczenia równoległe 5

6 OpenCL ukrywanie opóźnienia Ukrywanie opóźnienia (latency hiding) w dostępie do pamięci dla CPU i GPU Konieczne jest współbieżne wykonywanie co najmniej kilku (najlepiej kilkunastu) grup wątków (AMD wavefronts, NVIDIA warps) Podział na grupy wątków dokonujących jednoczesnego dostępu do pamięci jest ukryty przed programistą Krzysztof Banaś Obliczenia równoległe 6

7 OpenCL zależności danych Krzysztof Banaś Obliczenia równoległe 7

8 Projektowanie kerneli Model równoległości danych (data parallel programming) model zrównoleglenia: dekompozycja danych (data decomposition) każdy wątek realizuje ten sam kod (SPMD) synchronizacja sprzętowa (SIMD, SIMT) wątek operuje na danych, określanych za pomocą identyfikatorów OpenCL pozwala uzyskać informacje o liczbie wymiarów przestrzeni wątków, liczbie wątków (globalnej oraz w pojedynczej grupie), liczbie grup oraz o identyfikatorze wątku: lokalnym (w grupie), globalnym, a także o identyfikatorze grupy: get_work_dim() get_global_id(dim_id), get_local_id(dim_id) get_global_size(dim_id), get_local_size(dim_id) get_num_groups(dim_id), get_group_id(dim_id) Krzysztof Banaś Obliczenia równoległe 8

9 OpenCL model pamięci Spójność pamięci: dla wątków tej samej grupy spójny obraz pamięci jest uzyskiwany w punktach synchronizacji np. wywołanie barrier (CLK_GLOBAL_MEM_FENCE); barrier (CLK_LOCAL_MEM_FENCE); dla wszystkich wątków wykonujących kernel spójny obraz pamięci jest uzyskiwany po wykonaniu kernela Szybkość pamięci: global local: ponad 100GB/s zależna od wzorca dostępu (coalesced memory access) host global: 6GB/s (PCIe 2.0) Krzysztof Banaś Obliczenia równoległe 9

10 Przykład transpozycja macierzy Krzysztof Banaś Obliczenia równoległe 10

11 Przykład transpozycja macierzy Krzysztof Banaś Obliczenia równoległe 11

12 Przykład transpozycja macierzy Wykorzystanie: pamięci wspólnej: jako szybkiej pamięci podręcznej umożliwiającej komunikację pomiędzy watkami jawnej synchronizacji pracy wątków Krzysztof Banaś Obliczenia równoległe 12

13 CUDA kernel global void transpose( float *out, float *in, int w, int h ) { shared float block[block_dim*block_dim]; unsigned int xblock = blockdim.x * blockidx.x; unsigned int yblock = blockdim.y * blockidx.y; unsigned int xindex = xblock + threadidx.x; unsigned int yindex = yblock + threadidx.y; unsigned int index_out, index_transpose; if ( xindex < width && yindex < height ) { unsigned int index_in = width * yindex + xindex; unsigned int index_block = threadidx.y * BLOCK_DIM + threadidx.x; block[index_block] = in[index_in]; index_transpose = threadidx.x * BLOCK_DIM + threadidx.y; index_out = height * (xblock + threadidx.y) + yblock + threadidx.x; synchthreads(); if(xindex<width&&yindex<height) out[index_out]=block[index_transpose]; Krzysztof Banaś Obliczenia równoległe 13

14 Przykład mnożenie macierzy Przypomnienie: mnożenie macierzy jest algorytmem, dla którego przy nieskończonej liczbie rejestrów występuje bardzo korzystny stosunek liczby operacji do liczby dostępów do pamięci s pm = (2n 3 )/(3n 2 ) ~ 2n/3 (n rozmiar macierzy) przy małej liczbie rejestrów i małym rozmiarze pamięci podręcznej naiwna implementacja prowadzi do znacznego spadku stosunku s pm : s pm = (2n 3 )/(n ) ~ 2 implementacja naiwna schemat przechowywania wierszami: c(row, col) = c[row*n + col] for(i=0;i<n;i++){ for(j=0;j<n;j++){ c[i*n+j]=0.0; for(k=0;k<n;k++){ c[i*n+j] += a[i*n+k]*b[k*n+j]; Krzysztof Banaś Obliczenia równoległe 14

15 Przykład mnożenie macierzy Naiwna implementacja GPU jeden wątek na jeden element macierzy wynikowej C Operacje wyłącznie na pamięci globalnej Nieoptymalny dostęp do tablicy A kernel void mat_mul_1_kernel( global float* A, global float* B, global float* C, int N ) { int i; int row = get_global_id(1); int col = get_global_id(0); float temp = 0.0; for (i = 0; i < N; i++) { temp += A[row * N + i] * B[i * N + col]; C[row * N + col] = temp; Krzysztof Banaś Obliczenia równoległe 15

16 Przykład mnożenie macierzy Klasyczna technika optymalizacji blokowanie Wyróżnienie bloków w tablicach A, B i C przechowywanych w szybkiej pamięci Wykonanie jak największej liczby operacji na blokach w szybkiej pamięci Krzysztof Banaś Obliczenia równoległe 16

17 Przykład mnożenie macierzy Implementacja blokowania: wariant 1 duże bloki: rozmiar bloku dobrany tak, żeby blok mieścił się w szybkiej pamięci (cache blocking) pojedynczy wątek wykonuje obliczenia dla wielu wyrazów bloku wariant 2 małe bloki: rozmiar bloku dobrany tak, żeby wartości mogły być przechowywane w rejestrach dla CPU i jednego wątku wiele zmiennych dla GPU np. jedna zmienna, ale wiele wątków Krzysztof Banaś Obliczenia równoległe 17

18 Przykład mnożenie macierzy int row = get_global_id(1); int local_row = get_local_id(1); int col = get_global_id(0); int local_col = get_local_id(0); float temp = 0.0; int nr_blocks = N/BLOCK_SIZE; for(iblock = 0; iblock < nr_blocks; iblock++){ A_local[local_row * BLOCK_SIZE + local_col] = A[row * N + iblock*block_size + local_col]; B_local[local_row * BLOCK_SIZE + local_col] = B[(local_row+iblock*BLOCK_SIZE) * N + col]; barrier(clk_local_mem_fence); for(i=0; i< BLOCK_SIZE; i++){ temp += A_local[local_row*BLOCK_SIZE+i] * B_local[i*BLOCK_SIZE+local_col]; barrier(clk_local_mem_fence); C[row * N + col] = temp; Krzysztof Banaś Obliczenia równoległe 18