GPGPU és számítások heterogén rendszereken

Átírás

1 GPGPU és számítások heterogén rendszereken

2 Eichhardt Iván ELTE-s GPGPU óra anyagai

3 Gyors bevezetés a Párhuzamosságról OpenCL API Gyakorlati példák (C++) Párhuzamos programozás elméleti megközelítésben

4

5 Lassú a fény? Kevés a tranzisztor? Netán rosszul van megírva?

6 Kezdjük egy kis számolási példával A fény sebessége km/s. Van egy gépünk egy 3,5 GHz-es CPU-val. A proci 2 órajel alatt képes lebegőpontos összeadásra 1 méteres kábellel csatlakoztatunk egy USB merevlemezt. A következő adat a lemezen van, be kell olvasni. Hány összeadást tudna a proci addig elvégezni, amíg a lemezről az elektronok (~fénysebességgel) megérkeznek a CPU-ba?

7 A processzor órajele 3.5Ghz = Hz Egy órajel 1/ = 285,7 psec (pikosec). Két órajel (egy összeadás) 571,8 psec időt vesz igénybe. A fény ennyi idő alatt 3*10^8m/s *571,8 *10^-12s = 0.17m utat tesz meg. Méteres kábel esetén: 1m/0,17m ~=~ 6 utasításnyi idő. Tehát a CPU-nk 6 utasításnyi időt malmozott, amíg az adat megérkezett. és akkor egyéb lassító tényezővel nem is számoltunk... Pl. HDD tipikus elérése 20 msec......ami alatt a CPU szabadságra is mehet.

8 Az algoritmusaink egymás utáni (szekvenciális) lépésekből állnak. A független lépéseket lehetne egyszerre végrehajtani Kulcs: párhuzamosítás. Ami számtalan módon lehtséges. Természetesen mindennek megvan az ára.

9 Lassú a fény? Utaztassuk kevesebbet az adatokat! Mozgassunk egyszerre több adatot! (32, 64, ) Gyorsítótár! (Cache)

10 Kevés a tranzisztor? Párhuzamos architektúrák!

11 Kevés a tranzisztor? Párhuzamos architektúrák!

12 Kevés a tranzisztor? Párhuzamos architektúrák! SISD Single Instruction Single Data Minden utasítás a saját adatával foglalkozik. MIMD Multiple Instruction Multiple Data Egyszerre több utasítás dolgozik a saját adatain. Több processzormag Több szál / processzormag MISD Multiple Instruction Single Data Robusztusság SIMD Single Instruction Multiple Data Ugyan azt az utasítást több adaton végezzük el. GPU archihektúra

13 Csíkszélesség csökkentése. Több tranzisztor fér el egy helyen. ~14 nm <? Korlátok: Atomi méreteken: szivárgó áram. (atom átmérője ~ pikométer)

14 Nagy fejlődésen mentek át. Nagyon specializált, nem programozható hardware. Általános célú számításokra alkalmazható, programozható hardware.

15 Nagy fejlődésen mentek át.

16

17 GPGPU General-purpose computing on Graphics Processing Units Egy átlagos felhasználó számára a legnagyobb számítási teljesítmény a GPU-ból nyerhető ki. Ereje a párhuzamosságban rejlik.

18 Fehérjék feltekeredésének (folding) szimulációja H1N1 szimuláció Az elveszett Apollo 11 videó Források: Felülírt videó, néhány átvett, és egy felvétel egy monitorról, amin a videót játsszák le éppen. 100x-os gyorsítás Neuronhálók tanítása Deep Learning, stb.

19 FPGA, GPGPU, CPU Field-programmable gate array (FPGA) DES dekódolás esete Data Encryption Standard CPU: 16 millió kulcs / másodperc GPU: 250millió kulcs / másodperc (GTX-295) FPGA: ~1.8 milliárd kulcs / másodperc

20 H1N1 szimuláció L. Barney - Studying the H1N1 virus using NVIDIA GPUs, Nov Apollo 11 R. Wilson - DSP brings you a high-definition moon walk, Sep DES dekódolás Dr. Dobbs - Parallel algorithm leads to crypto breakthrough, Jan A GPGPU problémái A. Ghuloum - The problem(s) with GPGPU, Oct

21

22

23 Nincs szinkronizáció és kommunikáció Csővezeték alkalmazása Párhuzamosítás Alapműveletek: Map, Amplify, Reduce, Sum

24 Forrás:

25 SIMD GPU multiprocesszor (pl. Vertex tulajdonság streamek) CPU kiterjesztések (SSE*, 3DNow!, MMX, ) Adatközpontúság, erőteljesen párhuzamosítható Az adatot vektorként kezeljük Például (vec_res, v1, v bites float vektorok): vec_res.x = v1.x + v2.x; vec_res.y = v1.y + v2.y; vec_res.z = v1.z + v2.z; vec_res.w = v1.w + v2.w; Egy művelettel írható le

26 32-bit hosszú bináris sztringek Manhattan távolsága Ciklussal (Szekvenciális megoldás) int bitcount_naive(int x) { int count = 0; while (x!= 0) { if ((x & 1) == 1) { count++; } x >>= 1; } return count; }

27 32-bit hosszú bináris sztringek Manhattan távolsága Bármilyen meglepő, egy processzormagon is tudunk párhuzamosítani!

28 32-bit hosszú bináris sztringek Manhattan távolsága Párhuzamos megoldás unsigned int bitcount(unsigned int x) { x = (x & (0x )) + ((x >> 1) & (0x )); x = (x & (0x )) + ((x >> 2) & (0x )); x = (x & (0x0f0f0f0f)) + ((x >> 4) & (0x0f0f0f0f)); x = (x & (0x00ff00ff)) + ((x >> 8) & (0x00ff00ff)); x = (x & (0x0000ffff)) + ((x >> 16) & (0x0000ffff)); return x; }

29 128-bit hosszú bináris sztringek Manhattan távolsága unsigned int bitcount_128(unsigned int4 x) { const unsigned int4 a1(0x , 0x , 0x , 0x ); const unsigned int4 a2(0x , 0x , 0x , 0x ); const unsigned int4 a3(0x0f0f0f0f, 0x0f0f0f0f, 0x0f0f0f0f, 0x0f0f0f0f); const unsigned int4 a4(0x00ff00ff, 0x00ff00ff, 0x00ff00ff, 0x00ff00ff); const unsigned int4 a5(0x0000ffff, 0x0000ffff, 0x0000ffff, 0x0000ffff); } x = (x & (a1)) + ((x >> 1) & (a1)); x = (x & (a2)) + ((x >> 2) & (a2)); x = (x & (a3)) + ((x >> 4) & (a3)); x = (x & (a4)) + ((x >> 8) & (a4)); x = (x & (a5)) + ((x >> 16) & (a5)); return x.x + x.y + x.z + x.w;

30 Sok 128 hosszú bit-sztringre: K-NearestNeighbours 1 maggal, naiv megoldással: Lassú 1 maggal + SIMD: Párhuzamos: sokszoros gyorsulás 8 maggal CPU-n: még gyorsabb.. GPU-val (soksok mag): > NAGYON gyors!

31 Csak GPU-k GPGPU Stream programozás Compute Shader CUDA stb. (hardverközelibb) HETEROGENEOUS COMPUTING Több mint 1 fajta processzor (CPU, GPU,...) OpenCL szabvány Nyílt

32

33 Adat- és feladat párhuzamos modell Az OpenCL nyílt szabvány A Khronos Group felügyeli Az OpenCL-C nyelv ISO C99 szabvány részhalmaza Numerikus műveletek az IEEE754 alapján Heterogén platform támogatás A modell alkalmazható a modern GPU-kra, CPU-kra, Cell processzorra, DSP-kre, Intel Xenon Phi, Altera FPGA stb...

34 Mezei felhasználó számára is elérhető!!! (CPU / GPU) AMD (OpenCL >v2.0) ARM (OpenCL >v2.0) Intel (OpenCL >v2.0) NVIDIA (OpenCL v1.2) (Androidon is) Mi csak OpenCL v1.2-el foglalkozunk.

35 Mi csak OpenCL v1.2-el foglalkozunk.

36 Az OpenCL elemei Platform modell A Host és az eszköz kapcsolata Program modell Data-parallel és Task-parallel lehetőségek Végrehajtási séma Memória modell

37 Az OpenCL elemei Platform modell A Host és az eszköz kapcsolata Program modell Data-parallel és Task-parallel lehetőségek Végrehajtási séma Memória modell

38 Hoszt eszköz (Host) OpenCL eszköz (Compute Device, Device ) Számolási egység (Compute Unit, CU ) Pl.: NVidia kártyák multiprocesszora Feldolgozó egység (Processing Element, PE ) Pl.: Videokártya Stream processzora Pl.: CPU magja

39 Az OpenCL elemei Platform modell A Host és az eszköz kapcsolata Program modell Data-parallel és Task-parallel lehetőségek Végrehajtási séma Memória modell

40 Data-parallel és Task-parallel lehetőségek Data-parallel (Adat párhuzamos) modell Adat-feladat egység összerendelés Műveletsor végrehajtása több adatra A végrehajtás automatikus elosztása Task-parallel (Feladat párhuzamos) modell Több független feladat párhuzamos végrehajtása

41 Az OpenCL elemei Platform modell A Host és az eszköz kapcsolata Program modell Data-parallel és Task-parallel lehetőségek Végrehajtási séma Memória modell

42 Host feladata Kontextus kezelés Végrehajtás vezérlés Kernel program Számító Egységek vezérlése Egy munkacsoporton belül azonos feladat elvégzésére

43 Kernel program Feladat egységek (Work-Items) Globális azonosító (global ID) Minden munkacsoportban azonos program Egységenként eltérhet a vezérlés Munkacsoportok (Work-Groups) Index tér (NDRange)

44 Kernel program Feladat egységek (Work-Items) Munkacsoportok (Work-Groups) Munkacsoport azonosító (work-group ID) A feladat egységeknek lokális azonosító (local ID) Index tér (NDRange)

45 Kernel program Munkacsoportok (Work-Groups) Feladat egységek (Work-Items) Index tér (NDRange) N dimenziós problématér N = 1, 2, 3 Adott méretek N dimenzióban: Globális címtér Munkacsoport méret Azonosítók / indexelés N dimenzióban : Global ID [pl.: get_global_id(1)] Local ID [pl.: get_local_id(0)]

46 Kontextus (Context) Eszközök (Device) Kernelek (OpenCL függvények) Program objektumok (Program) Forrás Végrehajtható bináris Memória objektumok A Host és az Eszközök által használt memória A Kernelek ezt látják

47 Parancs sorok (command-queue) Host által ellenőrzött Kernelek végrehajtását vezérli Parancsok Kernel végrehajtás Memória műveletek (írás és olvasás) Szinkronizáció In-order / Out-of-order végrehajtási módok

48 Az OpenCL elemei Platform modell A Host és az eszköz kapcsolata Program modell Data-parallel és Task-parallel lehetőségek Végrehajtási séma Memória modell

49 Négy memória régió az Eszközön Globális Konstans Lokális Privát

50 Globális memória Írható / olvasható bármelyik Work-Itemből Bármely eleme elérhető bármely PE-ből A Host foglalja le (allokálja) a területet, végzi a másolást, és a memória felszabadítást.

51 Konstans memória A Globális memória csak olvasható megfelelője Kernelben statikusan is definiálható Néhány hardware külön erre a célra fenntartott, hatékony memóriaterülettel rendelkezik.

52 Lokális memória A Host nem fér hozzá Egy WG osztott memóriája Minden WI olvashatja/írhatja Privát memória A Host nem fér hozzá Csak az adott WI látja

53 A konzisztenciáról (Hol zavarnak be egymásnak a memória műveletek?) Work-Item szinten WI-ek között nem konzisztens, De egy WI-en belül konzisztens. Work-Group szinten Konzisztens Lokális és Globális memória egy WG-on belül Nem konzisztens a Globlális memória a WG-ok között

54 WorkGroup szinkronizáció WI-ek szinkronizációja Barrier Blokkoló hívás WG-ok között nincs szinkronizáció!!!! CommandQueue szinkronizáció Parancssori Barrier garantált a barrier előtti parancsok lefutása CQ-k között nincs szinkronizáció Várakozás Eseményre minden parancs generál egy eseményt, erre várakoztathatunk egy másikat

55 Az OpenCL C nyelv

56 C99 nyelv módosítva Skalár típusok Vektor típusok (n {2,4,8,16}) (u)charn (u)shortn (u)intn (u)longn floatn Vektor komponensek elérése (float4 f;) Swizzle (f.xyzw, f.x, f.xy, f.xxyy, stb.) Numerikus indexek Felezés (f.odd, f.even, f.lo, f.hi)

57 Implicit konverzió Korlátozott mértékben használható; skalártípusok között Explicit konverzió (Példák) float4 f = (float4)1.0; uchar4 u; int4 c = convert_int4(u); float f = 1.0f; uint u = as_uint(f); // 0x3f lesz az értéke

58 Memóriaterület-jelölők global, local, constant, private Például: global float4 color; Függvény-jelölők kernel Egy OpenCL C függvényt Kernelnek jelöl ki. attribute Fordító segítő attribútumok.

59 Beépített függvények a végrehajtási modellre vonatkozóan get_work_dim() size_t get_{global/local}_{id/size}(uint dimidx); Pl.: size_t id = get_global_id(1); size_t get_num_groups(uint dimidx); size_t get_group_id(uint dimidx);

60 Szinkronizációs függvények barrier(flag); CLK_LOCAL_MEM_FENCE : lokális memóriát konzisztensé teszi CLK_GLOBAL_MEM_FENCE : globális memóriát konzisztensé teszi mem_fence(flag); write_mem_fence(flag); read_mem_fence(flag);

61 További beépített függvények Általános, szokásos függvények Geometriai függvények Összehasonlító függvények floatn típusokon (isequal, isinfinite, stb) Memóriára vonatkozóan: Aszinkron memória olvasás Prefetch (cache-be töltés globális memóriából)

62 VexCL C++ template könyvtár vektor-kifejezések írására és futtatására OpenCL/CUDA-n SharpCL C# bytecoderól OpenCL-re fordít és futtat Érdeklődni az előadónál. HadoopCL MapReduce Heterogén rendszereken, Hadoop és OpenCL integrációval Apple OS X Snow Leopard

63

64 Esettanulmányok: Programozási minták (Elmélettel) Map (Gather) (Scatter) Stencil Reduce Scan

65

66

67 Leképezés Többváltozós függvény alkalmazása. Általában a többi tervezési mintával együtt használják. Így új tervminták jöhetnek létre. Az implementációról Helyben is végezhető (a bemeneten).

68 P P

69 P

70 Gather: A P feladat több helyről tetszése szerint gyűjt adatokat, melyből egy elemet hoz létre a kimeneten. P

71 P

72 Scatter: A P folyamat tetszése szerint több kimeneti elemet érint. P Például: A scatter során a P folyamat egy elem (módosított) értékét több másikhoz adja.

73

74 ~ Sablon Adott N hosszú input és N hosszú output. Az éppen feldolgozott elem valamilyen környezete alapján számolunk outputot. 1D, 2D, 3D,. Alkalmazás Pl.: Futószűrő (helyben végzett) Pl.: Elmosás (nem helyben végzett) Doboz szűrő, Gauss szűrő, Technikák Konvolúciók, Medián, Véges differenciák, Bilaterális szűrés, stb Implementáció Konvolúcióknál: Szeparábilis? => gyorsítás

75 Fontos szempont: A stencil egy fix minta alapján gyűjti az adatokat. A stencil minden kimenetre ír. Naiv megvalósításának problémája: Adat-újrafelhasználás. Kérdés: Mi a megoldás pl. átlagszűrő esetén? Táblás feladat: Kérdés: Hányszor fogunk olvasni egy-egy input adatelemet az adott minta alapján?

76 Kérdés: Milyen tervezési minta alapján működhet a következő Összegzés? Feltételes értékadás? Rendezés?

77 Map: Index tér (Bemenet, Kimenet) One-to-One Gather: Index tér Kimenet Many-to-One Scatter: Index tér Bemenet One-to-Many Stencil: Index tér (Bemenet*, Kimenet) Several-to-One

78

79

80 ~ Tömörítés Adott művelet: Asszociatív. Kommutatív? Adott bemenet, ahol értelmezett a művelet. A bemenetet a művelet segítségével redukáljuk egyetlen egységgé: Pl.: Számsorozat összege (művelet: összadás) Pl.: Maximumkiválasztás

81 Alkalmazások Összegzés, Maximum-kiválasztás Csak-asszociatív esetben: Scan tervezési minta egy lépése! ( Up-Sweep ) MapReduce Nagy klasztereken nagyon klassz!

82 Implementáció Végezhető helyben, vagy váltogatott bemenetkimenet tömbökön. Szinkronizáció szükséges a hatékony megvalósításhoz. Ha a műveletre teljesül: Asszociativitás: Alapeset. Kommutativitás: Bizonyos hardvereken előnyös lehet, ha a kommutativitást kihasználva egymás mellé rakjuk a lépésenként redukált sorozatokat. Nem maradnak közök az elemek között. SIMD

83 Lépés 1 Lépés 2 Lépés 3 Lépés 4 Értékek: get_id Értékek: get_id Értékek: get_id Értékek: get_id Értékek:

84 Értékek: Lépés 1 Lépés 2 Lépés 3 Lépés 4 get_id Értékek: get_id Értékek: get_id Értékek: get_id Értékek:

85

86

87 Asszociatív művelet eredménye Adott művelet: Asszociatív. (fogalom: ORSI-tantárgy) A művelet ismételt alkalmazásánál a részeredményeket is kiszámítjuk. Összehasonlítva: A Reduce leginkább csak a végeredménnyel törődik.

88 Alkalmazások A Radix rendezés egyik lépése. Változó szélességű képszűrés. Adatfolyam feldolgozás. Irodalom: Blelloch, Guy E "Prefix Sums and Their Applications." Technical Report CMU-CS , School of Computer Science, Carnegie Mellon University.

89 Implementáció Naiv megvalósítás: Nem munka -hatékony: O(n log 2 n) Hatékony megvalósítás: Kiegyensúlyozott fák mintájára (balanced trees) PP-ben hasznos algoritmikus minta!!! Bináris fa. A bemenet hosszával azonos nagyságrendű hatékonyság: O(n). A bináris fát nem tároljuk le, csak az elvet használjuk! Két lépésben: Up-Sweep fázis (Reduce minta) Down-Sweep fázis Irodalom: Belloch (1990)

90 Lépés 1 Értékek: get_id Értékek: Lépés 2 get_id Értékek: Lépés 3 get_id Értékek:

91 Az algoritmus két lépésben működik: Up-Sweep Down-Sweep Up-Sweep Egy csak-asszociatív Reduce. Down-Sweep 1. Az utolsó elem kinullázása. 2. A redukciós lépések végrehajtása fordított sorrendben: Nagy lépésektől a kisebbekig. Egy lépésre: 1. Eredmény := művelet(bal oldali elem, Jobb oldali elem) (Redukció) 2. Bal oldali elem := Jobb oldali elem. (Ez egy új lépés) 3. Jobb oldali elem := Eredmény. (Redukció befejezése) Más néven: Blelloch Scan

92 Köszönöm a figyelmet!

93

94

95