grafikus kártyák, mint olcsó szuperszámítógépek -...

GPU, mint szuperszámítógép – I. ( 1 )

Grafikus kártyák, mint olcsó szuperszámítógépek - I.

tanuló szeminárium

Jurek Zoltán, Tóth GyulaSZFKI, Röntgendiffrakciós csoport


VázlatI.

● Motiváció● Beüzemelés● C alapok● CUDA programozási modell, hardware adottságok

II.● Optimalizálás● Tippek (pl. több GPU egyidejű használata)● Könyvtárak (cuFFT, cuBLAS, ...)● GPU számolás CUDA programozás nélkül


Irodalom - CUDA● http://heim.ifi.uio.no/~knutm/geilo2008/seland.pdf

● CUDA, Supercomputing for the Masses Part 1-15http://www.drdobbs.com/cpp/207200659

● CUDA official manualsProgramming Guide, Reference Manual, Release Noteshttp://developer.nvidia.com/object/cuda_2_3_downloads.html


Irodalom - Egyéb● Kernighan, Ritchie: The C Programming Languagehttp://zanasi.chem.unisa.it/download/C.pdfhttp://www.windowsceportal.hu/download/doc/cpl_hu.zip

● OpenMP tutorialhttps://computing.llnl.gov/tutorials/openMP/

● MPI tutorialhttps://computing.llnl.gov/tutorials/mpi/


Motiváció


Szuperszámítógép GPU-ból


Moore törvényeTranzisztorok száma másfél-két évente duplázódik

Számítógép sebessége exp. növekszik

DEaz utóbbi ~4 évben megtorpant!

3GHz, 45nm


A párhuzamosítás korszaka!

● Nem a sebesség, hanem a processzorok száma nő

● Át kell gondolni algoritmusaink szerkezetét: soros párhuzamos


A párhuzamosítás korszaka!MPI (Message Passing Interface) - process szintű

● Tipikus sok gép(klaszter) esetén

● Külön memória a processznek

● Hálózati (TCP/IP) adattranszfer


A párhuzamosítás korszaka!OpenMP (Open Multi-Processing) – szál (thread) szintű

● Egy gép – sok mag esetén

● Szálak: közös memóriaterület + saját változók


Grafikus kártyák

nVidia GTX295:2 x 240 db 1.3GHz proc2 x 900MB memória

Tesla C10601 x 240 db 1.3GHz proc1 x 4000MB memória

GPU : Graphics Processing Unit


Grafikus kártyák● CPU + coprocesszor (GPU)

● 1920 mag, 14 Tflops (float) (FLoating point Operations Per Second)

200x asztali gép teljesítmény

● ,,Személyi szuperszámítógép”: 1 kutató, 1 számítógép ● Elérhető: megfizethető ár

win/linux/mac + C


Heterogén számolások

Host computer + Device


GPU vs. CPUTEXTSzámítási teljesítmény


GPU vs. CPUMemória sávszélesség


GPU vs. CPUSzál-végrehajtás

● CPU: MIMDMultiple Instruction, Multiple Data

● GPU: SIMD Single Instruction, Multiple Data


GPU vs. CPUA nagy memória (RAM) elérése rendkívül időigényes

(~100 órajel)

gyorsítás szükséges

CPU

~MB gyorsmemória (cache) a CPU-n

GPU

kicsi (~16kB) gyorsmemóriade ~128szál/mag hyperthreading


GPGPU programozás története● Kezdet: masszív GPU programozás

● Utóbbi években két fejlesztői környezet:- nVidia – Compute Unified Device Architecture, CUDA - AMD Firestream (ATI)

(- intel: Larrabee, ~x86)

● OpenCL (Open Computing Language): nyílt szabványheterogén rendszerek (pl. CPU+GPU) programozáshoz


CUDACompute Unified Device Architecture

● Magas szintű kiterjesztés a C/C++ nyelvhez

● CUDA programozási és memória modell

● nvcc fordító

GPUmagok számával skálázódó programok (kód újrafordítása nélkül)


PéldákTEXT


PéldákMolekula dinamika / kvantumkémia kódok + GPU


CUDA - Beüzemelés


CUDA eszközökhttp://www.nvidia.com/object/cuda_gpus.html


CUDA telepítésHardware:GPU: 4 x nVidia GTX295

(1920 x 1.3GHz mag)CPU: Intel(R) Xeon(R) CPU

E5520 @ 2.27GHz (8 valós +

8 virtuális mag)Software:OpenSuse 11.2 Linux

gcc-4.4.1kernel 2.6.31.5-0.1 x86_64




E5520 @ 2.27GHz (8 valós +


gcc-4.4.1kernel 2.6.31.5-0.1 x86_64


CUDA telepítésDriver (root-ként telepíteni)

nvidia.ko; /usr/lib64/libcuda.so

Toolkit (célszerű root-ként telepíteni)nvcc compiler; CUDA FFT,BLAS; profiler; gdb default install: /usr/local/cuda

SDK (Software Development Kit; lehet felhasználóként is telepíteni)Példaprogramok; ~/NVIDIA_GPU_Computing_SDK


CUDA letöltésekhttp://developer.nvidia.com/object/cuda_2_3_downloads.html


CUDA telepítésDriver NVIDIA-Linux-x86_64-190.53-pkg2.run

root@linux> sh NVIDIA-Linux-x86_64-190.53-pkg2.run

szükséges: Base-development (gcc, make)Kernel-devel (kernel-source, headers)

Toolkit cudatoolkit_2.3_linux_64_suse11.1.runroot@linux> sh cudatoolkit_2.3_linux_64_suse11.1.run

SDK cudasdk_2.3_linux.runuser@linux> sh cudasdk_2.3_linux.run


CUDA telepítés - rendszerbeállítások

● Futtatni release_notes_linux.txt (CUDA download page) scriptjét (-› load module, devs)

● ~/.bashrc-be:export PATH=/usr/local/cuda/binexport LD_LIBRARY_PATH=/usr/local/cuda/lib64

Megj. (”nem támogatott” linux esetén): ● nvcc nem kompatibilis gcc-4.4-gyel gcc-4.3● SDK példaprog.-hoz kellett: freeglut freeglut-devel


SDK - példaprogramok

Fordítás:

cd ~/NVIDIA_GPU_Computing_SDK/Cmake

Példaprogramok:

cd ~/NVIDIA_GPU_Computing_SDK/C/bin/linux/release ls


SDK - példaprogramokTEXT


C gyorstalpaló


C gyorstalpalómain függvény, változók

int main(void) // main fg. definiálás{

int i; // lokális változó def.

i=1; // értékadás

return(i); // fg. visszatérési érték}

// Ez egy komment

Adattípusok: int, float, double, char, ...


C gyorstalpaló

Fordítás:

gcc -o test.out test.c

Futtatás:

./test.out


C gyorstalpalóKülső függvények

#include <stdio.h> // küls� fg-ek deklarálásavoid main(void) // main fg. definiálás{

int i; // lokális változó def.

i=1; // értékadás

printf(”%d\n”,i); // küls� fg. hívása}

// Ez egy komment

Adattípusok: int, float, double, char, ...


C gyorstalpalóKülső függvények

#include <math.h> // #include <stdio.h>

void main(void){

double x;

x = sqrt(2.0); // Küls� fg.

printf(”%e\n”,x);}


C gyorstalpaló

Fordítás:

gcc -o test.out test.c -lm

Futtatás:

./test.out


C gyorstalpalóFüggvények

int foo(int i, int j) { // fg. definiálásreturn(j*i); // visszatérési érték

}

int main(void) // main fg. definiálás{

int i=1; // lokális változó def.

i = foo(2,i); // függvényhívás



C gyorstalpalóFüggvények

int foo(int i, int j); // fg. deklarálás

int main(void) { // main fg. definiálásint i=1; // lokális változó def.

i = foo(2,i); // függvényhívás


int foo(int i, int j) { // fg. definiálásreturn(j*i); // visszatérési érték

}


C gyorstalpalóMutatók

i

Memória

p

int i, *p ;

p = &i ;

*p i


C gyorstalpalóMutatók

#include <stdio.h>void main(void){

int i, *p; // mutató definiálás

i=1;

p = &i; // mutató i címéreprintf(”%d %d\n”,i,*p);// p értékének kiírása

*p = 2; // értékadás p értékéreprintf(”%d %d\n”,i,*p); // kiiratás

}


C gyorstalpalóMutatók - tömbök

p[0] p[2]

Memória

p

int *p ;

p = malloc(5*sizeof(int));

p[0] *p

p[2] *(p+2)

p+2

sizeof(int)


C gyorstalpalóTömbök - vektorok

#include <stdlib.h>void main(void) {

int i, *p, N=10;

p = (int*)malloc(N*sizeof(int)); //din.mem.f.

for (i=0; i<N; i=i+1) // tömbfeltöltés{

p[i] = 2*i; // vektorelem} // 2.0: double, 2.0f: float

free(p); // mem. felszabadítás}


C gyorstalpalóTömbök - mátrixok

#include <stdlib.h>void main(void) {

int i, j, *p, N=10, M=20;

p = (int*)malloc(N*M*sizeof(int)); //mem.f.

for (i=0; i<N; i=i+1) { for (j=0; j<M; j=j+1) {

p[i*M+j] = 2*(i*M+j); // tömbfeltöltés }

}free(p);

}


CUDA programozási modellés hardware felépítés


Programozási modell● A CPU egy számoló egysége (coprocesszora) a GPU.

● A CPU és GPU külön memóriával rendelkezik (adatmásolás)

● Az eszközre fordított objektum a kernel

● A szálanként (thread) futó kernel

● adatpárhuzamos sok azonos vázú számolás különböző adatokon


Kódséma

● CUDA programkód (”.cu” kiterjesztéssel)

● Fordítás nvcc fordítóval

● Futtatás

Megj.: célszerű egy könyvtárat létrehozni az adott részfeladat GPU-n történő elvégzéséhez, majd azt CPU-s programunkhoz kapcsolni (”linkelni”).


Kódséma CUDA programkód:

● GPU-n futó rész (kernel): fg., ami a számolási feladat időigényes részét számolja (általában eredetileg röveidebb CPU kódrész)

● CPU-n futó rész: adatelőkészítésadatmásolás a GPU-raGPU kernel futtatásaadatmásolás a GPU-ról


Futtatási modellEmlékeztető: OpenMP a CPU-n

Szálak: 0, 1, 2, ..., N-1

2

1

0

N-2

N-1

...2

1

0

N-2

N-1

...


SDK - deviceQuery


Fizikai felépítés

Reg

Reg

Global

SHARED

● N db multiprocessor (MP)● M db singleprocessor(SP) / MP

GeForce 9400M

GTX295

N 2 30M 8 8

Órajel 0.2 GHz 1.24 GHzMegj. dupla

kártya


Futtatási modell● A grid thread blockokból áll

● A threadek a kernelt hajtják végre

● A blockok számát és méretét (execution configuration) a host alkalmazás állítja be

● Azonosítás (beépített): blockIdx, threadIdx (blockon belül), blockDim idx = blockIdx.x * blockDim.x + threadIdx.x

Thread bSize-1

Thread 1

Thread 0

...

Block 0

Thread bSize-1

Thread 1

Thread 0

...

Block nBlck-1

DeviceGrid

...


Futtatási modellDeviceGrid

...0 1 2 3 0 1 2 3 0 1 2 3

gridDim.x = 3 , blockDim.x = 4

blockIdx.x=0 blockIdx.x=1 blockIdx.x=2

threadIdx.x:

Global threadID:idx = blockIdx.x * blockDim.x + threadIdx.x

0 1 2 3 4 5 6 7 8 9 10 11


Futtatási modell● A grid és a blockok méretét a host alkalmazás állítja be

● Grid dim.: 1 vagy 2

● Block dim.: 1, 2 vagy 3

pl. threadIdx.xthreadIdx.ythreadIdx.z


Példaprogram – soros CPU#include <stdlib.h>

void myfunc(float *v, int D, float c) { ... }

int main(void) { int i, D=1000000, s; float *h; s = D * sizeof(float); // size in bytes h = (float*) malloc(s); for (i=0; i<D; i=i+1) { h[i] = (float)i; } myfunc (h, D, 2.0f); free(h);}


Példaprogram – soros CPU#include <stdlib.h>

void myfunc(float *v, int D, float c) { int i; for (i=0; i<D; i=i+1) { v[i] = v[i] * c; }}

int main(void) { ...}

0 1 D


Példaprogram – párhuzamos CPU#include <stdlib.h>#include <omp.h>

void myfunc(float *v, int D, float c) { int id,N,i; N = omp_get_num_procs(); omp_set_num_threads(N); #pragma omp parallel private(id,i) { id = omp_get_thread_num(); for (i=id; i<D; i=i+N) { v[i] = v[i] * c; } }}

i i+N i+2Ni. thread:


Példaprogram - CUDA__device__ void mykernel(float *v, int D, float c) {…}

int main(void) { int i, D=1000000, s; float *h, *d; s = D * sizeof(float); cudaMallocHost((void**) &h, s); cudaMalloc( (void**) &d, s) ; for (i=0; i<D; i=i+1) { h[i] = (float)i; } cudaMemcpy( d, h, s, cudaMemcpyHostToDevice); dim3 grid (30); dim3 threads (32); mykernel <<< grid, threads >>> (d, D, 2.0f); cudaMemcpy( h, d, s, cudaMemcpyDeviceToHost); cudaFreeHost(h); cudaFree(d); }



int main(void) { // var. deklarációk int i, D=1000000, s; // tömb hossza byte-ban float *h, *d; s = D * sizeof(float); cudaMallocHost((void**) &h, s); cudaMalloc( (void**) &d, s) ; for (i=0; i<D; i=i+1) { h[i] = (float)i; } cudaMemcpy( d, h, s, cudaMemcpyHostToDevice); dim3 grid (30); dim3 threads (32); mykernel <<< grid, threads >>> (d, D, 2.0f); cudaMemcpy( h, d, s, cudaMemcpyDeviceToHost); cudaFreeHost(h); cudaFree(d); }



int main(void) { // mem. foglalás int i, D=1000000, s; // host-on és device-on float *h, *d; s = D * sizeof(float); cudaMallocHost((void**) &h, s); cudaMalloc( (void**) &d, s) ; for (i=0; i<D; i=i+1) { h[i] = (float)i; } cudaMemcpy( d, h, s, cudaMemcpyHostToDevice); dim3 grid (30); dim3 threads (32); mykernel <<< grid, threads >>> (d, D, 2.0f); cudaMemcpy( h, d, s, cudaMemcpyDeviceToHost); cudaFreeHost(h); cudaFree(d); }



int main(void) { // tömb inicializálás int i, D=1000000, s; float *h, *d; s = D * sizeof(float); cudaMallocHost((void**) &h, s); cudaMalloc( (void**) &d, s) ; for (i=0; i<D; i=i+1) { h[i] = (float)i; } cudaMemcpy( d, h, s, cudaMemcpyHostToDevice); dim3 grid (30); dim3 threads (32); mykernel <<< grid, threads >>> (d, D, 2.0f); cudaMemcpy( h, d, s, cudaMemcpyDeviceToHost); cudaFreeHost(h); cudaFree(d); }



int main(void) { // tömb másolása device-ra int i, D=1000000, s; float *h, *d; s = D * sizeof(float); cudaMallocHost((void**) &h, s); cudaMalloc( (void**) &d, s) ; for (i=0; i<D; i=i+1) { h[i] = (float)i; } cudaMemcpy( d, h, s, cudaMemcpyHostToDevice); dim3 grid (30); dim3 threads (32); mykernel <<< grid, threads >>> (d, D, 2.0f); cudaMemcpy( h, d, s, cudaMemcpyDeviceToHost); cudaFreeHost(h); cudaFree(d); }



int main(void) { // grid definiálás int i, D=1000000, s; float *h, *d; s = D * sizeof(float); cudaMallocHost((void**) &h, s); cudaMalloc( (void**) &d, s) ; for (i=0; i<D; i=i+1) { h[i] = (float)i; } cudaMemcpy( d, h, s, cudaMemcpyHostToDevice); dim3 grid (30); dim3 threads (32); mykernel <<< grid, threads >>> (d, D, 2.0f); cudaMemcpy( h, d, s, cudaMemcpyDeviceToHost); cudaFreeHost(h); cudaFree(d); }



int main(void) { // kernel futtatása device-on int i, D=1000000, s; // futtatási konfig. megadása float *h, *d; s = D * sizeof(float); cudaMallocHost((void**) &h, s); cudaMalloc( (void**) &d, s) ; for (i=0; i<D; i=i+1) { h[i] = (float)i; } cudaMemcpy( d, h, s, cudaMemcpyHostToDevice); dim3 grid (30); dim3 threads (32); mykernel <<< grid, threads >>> (d, D, 2.0f); cudaMemcpy( h, d, s, cudaMemcpyDeviceToHost); cudaFreeHost(h); cudaFree(d); }



int main(void) { // eredmény visszamásolása int i, D=1000000, s; float *h, *d; s = D * sizeof(float); cudaMallocHost((void**) &h, s); cudaMalloc( (void**) &d, s) ; for (i=0; i<D; i=i+1) { h[i] = (float)i; } cudaMemcpy( d, h, s, cudaMemcpyHostToDevice); dim3 grid (30); dim3 threads (32); mykernel <<< grid, threads >>> (d, D, 2.0f); cudaMemcpy( h, d, s, cudaMemcpyDeviceToHost); cudaFreeHost(h); cudaFree(d); }



int main(void) { // memóriafelszabadítás int i, D=1000000, s; // host-on és device-on float *h, *d; s = D * sizeof(float); cudaMallocHost((void**) &h, s); cudaMalloc( (void**) &d, s) ; for (i=0; i<D; i=i+1) { h[i] = (float)i; } cudaMemcpy( d, h, s, cudaMemcpyHostToDevice); dim3 grid (30); dim3 threads (32); mykernel <<< grid, threads >>> (d, D, 2.0f); cudaMemcpy( h, d, s, cudaMemcpyDeviceToHost); cudaFreeHost(h); cudaFree(d); }


Példaprogram - CUDA__device__ void mykernel(float *v, int D, float c) { int id,N,i;

id = blockIdx.x * blockDim.x + threadIdx.x ; N = gridDim.x * blockDim.x;

for (i=id; i<D; i=i+N) { v[i] = v[i] * c; }}

int main(void) { ...}

i i+N i+2Ni. thread:


Példaprogramok

Fordítás:

gcc -o testserial.out testserial.c

gcc -o testomp.out testomp.c -fopenmp -lgomp

nvcc -o testcuda.out testcuda.c


Aritmetika időigénye


GPU memóriaGlobal

Shared

Register

Constant

Texture

Local


GPU memóriaGlobal (~GB):

● lassú elérés (400-600 órajel)

● host és device írja, olvassa

● elérése gyorsítható, ha a szálak rendezetten olvasnak/írnak

pl. cudaMalloc cudaMemcpy


GPU memóriaRegister (16384 db):

● leggyorsabb memória● egy thread látja● csak device írja/olvassa

pl. kernel (__device__) lokális változói:

int id, N, i;


GPU memóriaShared (16kB):

● gyors● egy Block összes threadje látja

● csak device írja/olvassa

pl. kernelben: __shared__ float x[8]


GPU memóriaLocal:

● lassú (global-ban fekszik)

● csak egy thread látja● csak device írja/olvassa


GPU memóriaConstant: ld. irodalomTexture: ld. irodalom


GPU memória

Memória láthatóság R/W sebességGlobal grid RW lassúShared block RW gyorsRegister thread RW gyorsLocal thread RW lassú

Constant grid RO lassú/cache gyorsítTexture grid RO lassú/cache gyorsít


Fizikai végrehajtás● N db multiprocessor (MP)● M db singleprocessor(SP) / MP● Egy MP több Blockot is számol- egy Block-ot egy MP számol

● Minden Block SIMD csoportokra van osztva: warp- a warpok fizikailag egyszerre hajtódnak végre

● Egy warpot alkotó threadek ID-jai egymást követőek

● manapság a warp 32 szálból áll

Reg

Reg

Global

SHARED


CUDA � skálázódás


Következmények● # Block / # MP › 1

� minden MP számol● # Block / # MP › 2

� egy MP egyszerre több Blockot is számol● # Block / # MP › 100● egy Block erőforrás-igénye ≤ MP teljes erőforrása

shared memória, registeregy MP egyszerre több Blockot is számolhat

● egy warpon belüli thread-divergencia kerülendőa különböző ágak sorbarendezve hajtódnak végre


FOLYT. KÖV.: Optimalizálás

grafikus kártyák, mint olcsó szuperszámítógépek -...

Documents