GPGPU programozás lehetőségei Nagy Máté Ferenc Budapest ALICE – ELTE TTK Fizika MSc 2011 e-Science Café
Vázlat • Egy, (kettő,) sok. Bevezetés a sokszálas univerzumba. • A párhuzamosok a végtelenben találkoznak, avagy a debugging egy életforma. • A cél szentesíti az eszközt. Jelen architektúrák, és a jövő. • En guard. Válasszunk fegyvert!
Serial >> Paralell • Az egyszálas programok világában sok minden evidens, ami a párhuzamos programoknál korántsem az. • Tudjuk hol tart a vezérlés és óvakodunk a szegmentálási hibától. • Párhuzamos programok esetén ezek szintén igazak. (Részben…)
Serial >> Paralell
• Minden többszálas program két részből áll: • Kritikus – csak egy szál hajthatja végre. (nem párhuzamosítható) • Párhuzamos – evidens. • Akkor miért nincs párhuzamos program dömping?
Norbi titok • Nem minden feladat párhuzamosítható. A párhuzamosíthatóságnak több szintje van.
• Nem annyira intuitív, mint a soros kód. Több idő kifejleszteni, és a program használati ideje: Tteljes = Tfejlesztési + Thasználati
Az ördög a részletekben • Az előző ábránk szép és jó, csak éppen nem sugallja a quint essencia-ját a dolognak. Pseudocode: int main() { ciklushossz = 100; a[8] = 0; b = 1; #pragma fork(8) for(i = 0 ; i < ciklushossz ; ++i) a[threadID] += b; cout << „Thread #” << threadID << „ finished.\n”; #pragma join return 0; }
user> ./pelda user> Thread #3 finished. user> Thread #0 finished. user> Thread #6 finished. user> Thread #7 finished. user> Thread #2 finished. user> Thread #4 finished. user> Thread #1 finished. user> Thread #5 finished. user> ./pelda user> Thread #0 finished. user> Thread #1 finished. user> Thread #5 finished. user> Thread #7 finished. user> Thread #3 finished. user> Thread #4 finished. user> Thread #2 finished. user> Thread #6 finished. user> |
Az ördög visszatér • És ha ez nem volna elég: Pseudocode: int main() { a = 0; b = 1; #pragma fork(2) a += b; cout << „Thread #” << threadID; cout << „ calculated ” << a << „\n”; #pragma join return 0; }
• És ez még csak a kezdet…
user> ./pelda user> Thread #0 calculated 1. user> Thread #1 calculated 2. user> ./pelda user> Thread #1 calculated 1. user> Thread #0 calculated 2. user> ./pelda user> Thread #1 calculated 2. user> Thread #0 calculated 1. user> ./pelda user> Thread #1 calculated 1. user> Thread #0 calculated 1. user> |
Bolyai János nyomában • Tehát a párhuzamosok találkoznak. • Szinkronizációs hibák debuggolása nem egyszerű feladat. Főleg hogy felismerni se mindig egyszerű. • Megoldás: Think before you type! • Legjobb védekezés a megelőzés! • Soros kóddal kezdünk programozni, hogy igazoljuk a párhuzamos algoritmus helyességét.
Grafika a tudomány szolgálatában • Grafikus kártyák programozásakor még körültekintőbben kell eljárnunk. • A GPU célhardver, egy feladatra van kitalálva. • Ez a feladat a képalkotás, nem az általános számítások. • Akkor mégis hogyan lehet használni? Ismerni kell a kártyákat, a képességeit és a korlátaikat. • Ha ennyire nem triviális, akkor miért csináljuk?
Mert már Moore is megmondta… CPU-GPU fejlődés Teljesítmény [GFLOPS]
6000
5000 4000
AMD
3000
NVIDIA
2000
CPU
1000 0
Egység
Phenom X6 1055 Radeon HD6990 GPU/CPU
Kapacitás (SP) *GFLOPS+
74,8
5099
68,168
Kapacitás (DP) *GFLOPS+ Fogyasztás *Watt+ Kapacitás:fogyasztás [GFLOPS/Watt]
74,8 125
1276 375
17,058 3
0,5984
13,597
22,722
A Létező Erők
In memoriam Enrico Fermi
• Az első cGPU (compute GPU) • Fejlett memória architektúra: többszintű olvasható/írható cache hierarchia. • CUDA magok felépítése átmenet a CPU és a hagyományos árnyalók között. • 1600 GFLOPS SP, 650 GFLOPS DP • 3-6 GB VRAM / GPU
Cayman trópusok nélkül
• Javarészt grafika, kis tuning GPGPU-ra. • Óriási árnyaló kapacitás. Kihasználása nehezebb, de nagyobb teljesítménnyel kecsegtet. • Stream magok felépítése grafika orinteált, négyes vektor és mátrix műveletekre optimalizált. • 2700 GFLOPS SP , 680 GFLOPS DP • 1-2 GB VRAM / GPU (HPC dual-core)
Llano, egy csipetnyi Texas
• Első heterogén módon programozható APU. 4 processzormag, és 400 árnyaló processzort felvonultató egyveleg. CPU-ba épített masszív párhuzamos kapacitás.
Sandy Bridge, Izráel hídja
• Intel első lépése a heterogén programozhatóság felé. • 4 processzormag és egy DirectX-képes integrált video vezérlő (IGP). • A szoftveres támogatása és az IGP felépítése nem teszi alkalmassá GPGPU számításokra. A 22 nm-en készülő utód (Ivy Bridge) az IGP minőségére helyezi a hangsúlyt.
Hogy mit hoz a jövő?
GCN, Graphics Core Next
• Erősen átdolgozott architektúra, Fermihez hasonlatosan cGPU orientált. • Újítások: vektor feldolgozók helyett skalár processzorok, teljes C/C++ támogatás (virtuális függvények, DLL, …), virtuális memória névtér CPU-val közösen, koherens memória CPU-val, aszinkron felépítés, új memória architektúra, 1:2 DP:SP kapacitás, 22 nm-es csíkszélesség, … • Várhatóan 2011 decemberében mutatkozik a nagyérdemű előtt.
In memoriam Johannes Kepler
• A lehető legnagyobb csend övezi az új generációs GPU-kat. • Újítások többnyire spekulációk, fenntartással kezelendők. • Valószínűleg: architekturálisan Fermire fog hasonlítani nagy mértékben, CUDA magok natív 64-bitesek lesznek (??). • Biztosan 22 nm-re épül. • Tape out fázis, várható megjelenés 2012 Q1.
Knight’s Corner, lovagregény
• Az Intel egy sikertelen víziójának újragondolása. • ~50 db x86 magot tartalmazó PCI-E foglalatba illeszkedő kártya. • GPU-khoz hasonlóan on-board RAM-ot tartalmaz. • 22 nm-es csíkszélesség. • Megjelenés: 2012 Q?.
Most légy okos Domokos! • • • • •
Melyik lesz a befutó? Válasz: nem tudjuk. (Hitvallás kérdése) Najó, de akkor mégis melyiket válasszuk? Válasz: az attól függ… Hordozható kódot akarunk, vagy teljesítmény orientáltat. • A teljesítménybeli különbség a két verzió között nagyon feladat specifikus. (1-10X)
Az arzenál • OpenCL: Apple kezdeményezés, ma már a Khronos.org kezelésében lévő nyílt szabvány. Párhuzamos alkalmazások közös nevezőjét definiáló, a gyártók saját implementációját igénylő szabvány. Platform független. • DirectX: A Microsoft tulajdonában lévő API, amely gyártótól függetlenül kínál Windows alatt általános számításra alkalmas felületet (Compute Shader). • C++ AMP: Szintén Microsoft kezdeményezés, ami a DirectXszel ellentétben platform független is. DirectX-képes hardverek számára kínál, C++ nyelvből elérhető, kényelmes párhuzamos program fejlesztői környezetet. • CUDA: platform-független, gyártó-specifikus API, amivel NVIDIA kártyákat programozhatunk kényelmesen és hatékonyan. Alacsony szintű nyelv.
Mi lebegjen a szemünk előtt? • „GPU programming is all about organizing your data.” • „Memory bandwidth is limited. Shader capacity is practically infinite.” • „GPU-t (célhardvert) programozunk!” • „Nem írok le olyat, amiről már akkor tudom hogy rossz, amikor begépeltem.” • Továbbá…
Kerüljük ahol tudjuk: • Szinkronizációt. CSAK akkor használjuk, ha algoritmikusan elkerülhetetlen. • Atomic műveleteket. Szintén, csak ha elkerülhetetlen. Sok számítás árán is megéri kerülni. • Adatmozgatást. Sávszélt ahol lehet árnyaló műveletre cserélünk. • DIV, MOD, TRANS műveleteket. • ALU-FETCH módok közötti váltást.
OpenCL szerkezet Platform
CPU HOST
CU
CU
CU
GPU Device
GPU Device
VRAM
VRAM
RAM
Context
Kernel1
Device list
Kernel2
Buffer1
Kernel3
Buffer2 Image1
Command Queue
Command Queue
Command Queue
Command Queue
Kernel4 Kernel5
Program felépítése • • • • • •
• •
• •
Platformot választunk (1-et vagy többet is akár) Lekérdezzük a Device-ok listáját. Contextet hozunk létre 1 Deviceszal. Betöltünk egy Programot forrásból vagy binárisból. A programból Kernel függvényeket válogatunk. Lefordítjuk a Kerneleket Deviceokra. CommandQueue-t hozunk létre a contexthez. Memóriaobjektumokat hozunk létre Host-Device és Device-Device közti adatmozgatáshoz. CommandQueue-n keresztül indítjuk a kerneleket. Szükség szerint Eventekkel szinkronizálunk.
Köszönöm a figyelmet!
