OpenCL
Az oldal jelenlegi verzióját még nem ellenőrizték tapasztalt közreműködők, és jelentősen eltérhet a 2022. március 15-én felülvizsgált
verziótól ; az ellenőrzések 2 szerkesztést igényelnek .
Az OpenCL ( Eng. Open C omputing L Anguage - open computing language) egy keretrendszer a párhuzamos számításokhoz kapcsolódó számítógépes programok írásához különböző grafikus és központi processzorokon , valamint FPGA -n . Az OpenCL tartalmaz egy programozási nyelvet , amely a C99 programozási nyelv szabványon alapul, és egy alkalmazásprogramozási felületet . Az OpenCL utasítás- és adatszintű párhuzamosságot biztosít, és a GPGPU -technika megvalósítása . Az OpenCL egy teljesen nyílt szabvány , és nem kell licencdíjat fizetni a használatáért.
Az OpenCL célja, hogy kiegészítse a 3D számítógépes grafika és hang nyílt iparági szabványait – az OpenGL -t és az OpenAL -t – a nagy teljesítményű számítástechnika GPU -képességeivel. Az OpenCL-t a Khronos Group fejleszti és tartja karban, egy non-profit konzorcium , amelybe számos nagy cég tartozik, köztük az AMD , az Apple , az ARM , az Intel , az Nvidia , a Sony Computer Entertainment és mások.
Történelem
Az OpenCL-t eredetileg az Apple Inc. fejlesztette ki. Az Apple javaslatokat nyújtott be a specifikáció kidolgozására a Khronos bizottságnak. Hamarosan az AMD úgy döntött, hogy támogatja az OpenCL (és a DirectX 11 ) fejlesztését, amely felváltja a Close to Metal keretrendszert . [1] [2]
2008. június 16-án megalakult a Khronos Compute Working Group az OpenCL specifikációk kidolgozására. Ide tartozik az Apple , az nVidia , az AMD , az IBM , az Intel , az ARM , a Motorola és más cégek, köztük a számítógépes játékok készítésére szakosodott cégek. A munka öt hónapig zajlott, ezt követően 2008. december 9- én a Khronos Group bemutatta a szabvány első változatát.
Az OpenCL 1.0 -t először 2008. június 9-én mutatták be a nagyközönségnek, majd 2009. augusztus 28-án adták ki Mac OS X 10.6 -tal. [3]
2009. április 5- én az AMD bejelentette , hogy letölthető az ATI Stream SDK v2.0 béta verziója, amely az OpenCL többprocesszoros programozási nyelvet tartalmazza.
2009. április 20- án az nVidia kiadott egy béta illesztőprogramot és szoftverfejlesztő készletet ( SDK ), amely támogatja a nyílt GPGPU szabványt, az OpenCL-t. Ez a béta-illesztőprogram az OpenCL Early Access programban részt vevő fejlesztőknek készült, akik részt vehetnek az április 20-án kezdődő bétatesztben. A GPU Computing Registered Developers tagok számára az OpenCL illesztőprogram béta verziója egy későbbi időpontban válik elérhetővé. [4] [5] [6]
2009. november 26- án az nVidia kiadott egy meghajtót, amely támogatja az OpenCL 1.0-t (48-as verzió).
Annak vizuális megjelenítéséhez, hogy az OpenCL technológia hogyan használja a 24 magos rendszer képességeit a videoeffektusok megjelenítésére, javasoljuk, hogy nézze meg a következő bemutatót: [1] Archivált 2017. március 9-én a Wayback Machine -nél .
Az OpenCL 1.1 -et a Khronos Group 2010. június 14-én mutatta be . Az új verzió jelentősen kibővíti a párhuzamos programozás funkcionalitását, a rugalmasságot és a teljesítményt, valamint új funkciókat ad hozzá.
- Új adattípusok, beleértve a 3 komponensű vektorokat és további képformátumokat.
- Parancsok feldolgozása több gazdagép szálból és pufferfeldolgozás több eszköz között.
- Pufferrégió műveletek, beleértve az 1D, 2D vagy 3D téglalap alakú régiók olvasását, írását és másolását.
- Az esemény kiterjesztett használata a parancsok végrehajtásának kezelésére és vezérlésére.
- Továbbfejlesztett együttműködés az OpenGL-lel a hatékony képmegosztás révén.
Az OpenCL 1.2 -t 2011. november 15-én mutatták be . Az új verzió számos apró fejlesztést tartalmaz a megnövekedett nyelvi rugalmasság és a teljesítmény optimalizálása érdekében. Az OpenCL 1.2 számos jelentős újítással bővült.
- Az eszközparticionálás az eszköz több aleszközre történő particionálása az OpenCL-alkalmazások szintjén, hogy a jobokat közvetlenül meghatározott számítási egységekhez rendelje, erőforrásokat lefoglaljon magasabb prioritású feladatokhoz, vagy hatékonyabban megosszon hardvererőforrásokat, például gyorsítótárat.
- Objektumok külön fordítása és összekapcsolása - lehetővé vált olyan dinamikus könyvtárak létrehozása, amelyek lehetővé teszik a korábban megvalósított rutinok használatát az OpenCL számításokkal harmadik féltől származó programokban.
- Kibővített képtámogatás, beleértve az 1D-s képekkel és 1D-s vagy 2D-s képek tömbjeivel való munkát. Ezenkívül a megosztási bővítmény lehetőséget ad OpenCL-kép létrehozására egyedi OpenGL-textúrák vagy textúratömbök alapján.
- A beágyazott OpenCL kernelek mostantól lehetővé teszik az egyéni vagy nem programozható hardver és a kapcsolódó firmware előnyeinek kihasználását. Például lehetővé vált az olyan eszközök képességeinek használata és szorosabb integrációja az OpenCL keretrendszerrel, mint a DSP processzorok vagy videó kódolók/dekóderek.
- Lehetőség a felületek zökkenőmentes megosztására (Media Surface Sharing) az OpenCL és az API DirectX 9/11 között.
Az OpenCL 2.0 -t 2013. július 22-én vezették be [7] , és ugyanazon év november 18-án szabványosították [8] .
- Megosztott virtuális memória – Lehetővé teszi a gazdagép és az eszközmagok számára, hogy összetett címreferenciákon alapuló adatstruktúrákat osszanak meg, kiküszöbölve a gazdagép és az eszközök közötti explicit átvitelt, miközben növeli a programozási rugalmasságot.
- Beágyazott párhuzamosság – A frissítés javította a programozási élményt és növelte az alkalmazások teljesítményét.
- Univerzális címtér – Lehetővé teszi függvények írását címterület elnevezése nélkül, ami növeli a rugalmasságot és időt takarít meg, mivel nincs szükség több függvény írására.
- Eszközoldali Atomic C11 műveletek – A C11 atomikus és szinkronizáló műveletek egy részhalmaza lehetővé teszi a szálak párhuzamos végrehajtását, hogy biztonságosan működjenek a megosztott adatkészleteken.
- Csatornák – FIFO-módszerrel rendezett memóriaobjektumok, amelyek leegyszerűsítik a megosztott sor adatszerkezetét.
Az OpenCL 2.1 -et 2015. március 3-án vezették be, és ugyanazon év november 16-án szabványosították. Átírta a magot C-ről C++14 -re .
Az OpenCL 3.0 -t 2020. április 27-én vezették be [9] , és ugyanazon év szeptember 30-án szabványosították [10] . A figyelemre méltó változások közé tartozik, hogy az OpenCL 3.0 API mostantól lefedi az OpenCL összes verzióját (1.2, 2.x), anélkül, hogy minden verzióhoz külön specifikációt adna.
Események
- 2011. március 3. – A Khronos Group bejelenti a WebCL munkacsoport létrehozását az OpenCL szabványnak megfelelő JavaScript felület fejlesztésére. Ez lehetőséget teremt a GPU-k és többmagos processzorok használatára a számítások párhuzamos feldolgozására egy webböngészőben. [tizenegy]
- 2011. május 4. – A Nokia Research kiadott egy nyílt forráskódú WebCL-bővítményt a Firefox böngészőhöz . [tizenegy]
- 2011. július 1. – A Samsung Electronics kiadott egy nyílt WebCL prototípust a WebKit motorhoz . [tizenegy]
- 2011. augusztus 8. – Az AMD kiadta az AMD Accelerated Parallel Processing (APP) Software Development Kit (SDK) v2.5 OpenCL illesztőprogramját, amely az ATI Stream SDK-t váltotta fel.
- 2011. november 15. – A Khronos bizottság kiadott egy frissített OpenCL 1.2 specifikációt. Az új verzió számos apró fejlesztést tartalmaz a megnövekedett nyelvi rugalmasság és a teljesítmény optimalizálása érdekében.
- 2012. december 1. – A Khronos bizottság újabb frissítést adott ki az OpenCL 1.2 specifikációjához. Az új verzió javította az OpenGL-lel való interakciót, javította a WebGL biztonságát, és hozzáadott támogatást az OpenCL programok betöltéséhez a SPIR köztes reprezentációból.
A nyelv jellemzői
A legfontosabb különbségek a használt nyelv és a C (1999-es ISO szabvány) között a következők:
- a függvénymutatók , rekurzió , bitmezők , változó hosszúságú tömbök (VLA), szabványos fejlécfájlok támogatásának hiánya [12] ;
- nyelvi kiterjesztések a párhuzamossághoz: vektortípusok, szinkronizálás, függvények munkaelemekhez/munkacsoportokhoz [12] ;
- memóriatípus minősítők: __global, __local, __constant, __private;
- különböző beépített funkciók.
Példák
FFT számítási példa :
[13]
// számítási környezet létrehozása a GPU (videokártya)
környezethez = clCreateContextFromType ( NULL , CL_DEVICE_TYPE_GPU , NULL , NULL , NULL );
// parancssor létrehozása
queue = clCreateCommandQueue ( kontextus , NULL , 0 , NULL );
// memóriafoglalás pufferek formájában
memobjs [ 0 ] = clCreateBuffer ( kontextus , CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR , sizeof ( float ) * 2 * bejegyzések száma , srcA , NULL );
memobjs [ 1 ] = clCreateBuffer ( kontextus , CL_MEM_READ_WRITE , sizeof ( float ) * 2 * bejegyzések száma , NULL , NULL );
// program létrehozása a forrásprogramból
= clCreateProgramWithSource ( contextus , 1 , & fft1D_1024_kernel_src , NULL , NULL ) ;
// a
clBuildProgram program lefordítása ( program , 0 , NULL , NULL , NULL , NULL );
// kernel objektum létrehozása lefordított programból
kernel = clCreateKernel ( program , "fft1D_1024" , NULL );
// argumentumok előkészítése
clSetKernelArg ( kernel , 0 , sizeof ( cl_mem ), ( void * ) & memobjs [ 0 ]);
clSetKernelArg ( kernel , 1 , sizeof ( cl_mem ), ( void * ) & memobjs [ 1 ]);
clSetKernelArg ( kernel , 2 , sizeof ( float ) * ( local_work_size [ 0 ] + 1 ) * 16 , NULL );
clSetKernelArg ( kernel , 3 , sizeof ( float ) * ( local_work_size [ 0 ] + 1 ) * 16 , NULL );
// az ND tartomány beállítása munkaelem dimenziókkal és elküldése a végrehajtási
sorba global_work_size [ 0 ] = num_entries ;
helyi_munkaméret [ 0 ] = 64 ;
clEnqueueNDRangeKernel ( sor , kernel , 1 , NULL , global_worksize , local_worksize , 0 , NULL , NULL );
Közvetlen számítások (az FFT G80 Architecture jelentésbe illesztése alapján) [14] :
// Ez a kód az 1024 hosszúságú FFT-t úgy számítja ki, hogy felosztja 16-ra, 16-ra és 4-re
__kernel void fft1D_1024 ( __global float2 * be , __global float2 * out ,
__local float * sMemx , __local float * sMemy ) {
int tid = get_local_id ( 0 );
int blockIdx = get_group_id ( 0 ) * 1024 + tid ;
float2data [ 16 ] ;
// a feldolgozott adatok kezdetének címe a globális memóriában
in = in + blockIdx ; out = out + blockIdx ;
globalLoads ( adatok , in , 64 ); // egyesített globális olvasások fftRadix16Pass ( adatok ); // in-place radix-16 pass twiddleFactorMul ( data , tid , 1024 , 0 );
// helyi keverés helyi memória használatával
localShuffle ( data , sMemx , sMemy , tid , ((( tid & 15 ) * 65 ) + ( tid >> 4 )));
fftRadix16Pass ( adatok ); // in-place radix-16 pass twiddleFactorMul ( data , tid , 64 , 4 ); // twiddle tényező szorzás
localShuffle ( data , sMemx , sMemy , tid , ((( tid >> 4 ) * 64 ) + ( tid & 15 )));
// 4 FFT hívás sorrendben 4
fftRadix4Pass ( adat ); // radix-4 függvény száma 1 fftRadix4Pass ( adat + 4 ); // radix-4 függvény száma 2 fftRadix4Pass ( adat + 8 ); // radix-4 függvény száma 3 fftRadix4Pass ( adat + 12 ); // radix-4 függvény száma 4
// összevont globális írja
globalStores ( adat , ki , 64 );
}
Az FFT OpenCL-ben való teljes megvalósítása elérhető az Apple webhelyén [15] .
Alkalmazás
Az OpenCL-t az általános célú GPU -koncepció egyik megvalósításaként használják különféle szoftverekben.
- WinZip v16.5 ( 2012 ) a Coreltől - a többmagos processzorokra való optimalizálást javító frissített motoron kívül az AMD GPU -k OpenCL támogatása is bekerült (az Intelhez és az Nvidiához azonban nem) - miközben a teljesítmény növekszik ebben A Trinity és Llano APU-kon történő alkalmazás akár 45%-ot is elért. [16]
Lásd még
Jegyzetek
- ↑ AMD meghajtók Ipari szabványok átvétele a GPGPU szoftverfejlesztésben . AMD. Az eredetiből archiválva : 2012. március 19. (határozatlan)
- ↑ Az AMD támogatja az OpenCL-t, a Microsoft DirectX 11-et . eWeek. Az eredetiből archiválva : 2012. március 19. (határozatlan)
- ↑ Az Apple a Mac OS X Snow Leopard előnézetét a fejlesztőknek . Alma. Az eredetiből archiválva : 2012. március 19. (határozatlan)
- ↑ Andrew Humber. Az NVIDIA OpenCL illesztőprogramot ad ki a fejlesztőknek . NVIDIA (2009. április 20.). - Eredeti hírek az NVIDIA Corporation hivatalos honlapján. Letöltve: 2009. április 21. Az eredetiből archiválva : 2012. március 19.
- ↑ Pavel Shubsky. Az NVIDIA megnyitotta a GPGPU-t a fejlesztők számára OpenCL alatt (nem elérhető hivatkozás) . Igromania (magazin) (2009. április 21.). Letöltve: 2009. április 21. Az eredetiből archiválva : 2009. április 25.. (határozatlan)
- ↑ Szergej és Marina Bondarenko. OpenCL illesztőprogram fejlesztőknek az NVIDIA-tól . 3DNews (2009. április 21.). Letöltve: 2009. április 21. Az eredetiből archiválva : 2009. április 23.. (határozatlan)
- ↑ A Khronos kiadta az OpenCL 2.0 -t . khronos.org (2013. július 22.). Letöltve: 2013. július 22. Az eredetiből archiválva : 2013. augusztus 17..
- ↑ A Khronos véglegesíti az OpenCL 2.0 specifikációt a Heterogeneous Computing számára , Khronos Group ( 2013. november 18.). Archiválva : 2020. november 11. Letöltve: 2013. november 20.
- ↑ A Khronos Group kiadta az OpenCL 3.0 ideiglenes specifikációit . Khronos Group (2020. április 27.). Letöltve: 2020. április 27. Az eredetiből archiválva : 2021. január 18.
- ↑ Az OpenCL 3.0 specifikáció véglegesítése és a kezdeti Khronos nyílt forráskódú OpenCL SDK megjelent . Khronos Group (2020. szeptember 30.). Letöltve: 2020. szeptember 30. Az eredetiből archiválva : 2020. szeptember 30.
- ↑ 1 2 3 A WebKit számára bemutatott WebCL technológia megvalósítása . opennet.ru (2011. július 4.). Letöltve: 2011. október 31. Az eredetiből archiválva : 2012. május 18.. (Orosz)
- ↑ 12 AMD . Bevezetés az OpenCL Programing 201005-be, 89-90. oldal
- ↑ OpenCL . SIGGRAPH2008 (2008. augusztus 14.). Letöltve: 2008. augusztus 14. Az eredetiből archiválva : 2012. március 19. (határozatlan)
- ↑ FFT illesztése a G80 architektúrára (PDF). Vaszilij Volkov és Brian Kazian, UC Berkeley CS258 projektjelentés (2008. május). Letöltve: 2008. november 14. Az eredetiből archiválva : 2012. március 19.
(határozatlan)
- ↑ .
OpenCL FFT-n (nem elérhető link) . Apple (2009. november 16.). Letöltve: 2009. december 7. Az eredetiből archiválva : 2009. november 30.. (határozatlan)
- ↑ AMD Trinity Benchmarks – OpenCL archiválva : 2012. augusztus 29. a Wayback Machine -nél // THG
Irodalom
- Aaftab Munshi; Benedict R. Gaster; Timothy G. Mattson; James Fung; Dan Ginsburg. OpenCL programozási útmutató. - Addison-Wesley Professional, 2011. - 648 p. — ISBN 978-0-321-74964-2 .
Linkek