OpenCL

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 15 mars 2022; kontroller kräver 2 redigeringar .
OpenCL
Sorts API
Författare Äpple
Utvecklaren Khronos Group
Skrivet i C++ och C
Operativ system Programvara för flera plattformar
Första upplagan 28 augusti 2009
Hårdvaruplattform x86_64 , IA-32 och ARM
senaste versionen 3.0.11 (6 maj 2022)
Licens EULA
Hemsida khronos.org/opencl/
 Mediafiler på Wikimedia Commons

OpenCL ( Eng.  Open C omputing L anguage-  open computing language) är ett ramverk för att skriva datorprogram relaterade till parallell beräkning på olika grafik- och centralprocessorer , samt FPGA . OpenCL inkluderar ett programmeringsspråk som är baserat på programmeringsspråksstandarden C99 och ett applikationsprogrammeringsgränssnitt . OpenCL tillhandahåller parallellitet på instruktionsnivå och datanivå och är en implementering av GPGPU- tekniken . OpenCL är en helt öppen standard och det finns inga licensavgifter för att använda den.

Målet med OpenCL är att komplettera de öppna industristandarderna för 3D-datorgrafik och ljud – OpenGL respektive OpenAL – med GPU -funktioner för högpresterande datoranvändning. OpenCL utvecklas och underhålls av Khronos Group , ett ideellt konsortium som inkluderar många stora företag inklusive AMD , Apple , ARM , Intel , Nvidia , Sony Computer Entertainment och andra.

Historik

OpenCL utvecklades ursprungligen av Apple Inc. Apple har lämnat in förslag för utveckling av specifikationen till Khronos-kommittén. Snart beslutade AMD att stödja utvecklingen av OpenCL (och DirectX 11 ), som borde ersätta Close to Metal -ramverket . [1] [2]

Den 16 juni 2008 bildades Khronos Compute Working Group för att utveckla OpenCL-specifikationer. Det inkluderar Apple , nVidia , AMD , IBM , Intel , ARM , Motorola och andra företag, inklusive de som specialiserar sig på att skapa datorspel. Arbetet pågick under fem månader, varefter Khronos Group den 9 december 2008 presenterade den första versionen av standarden.

OpenCL 1.0 visades först för allmänheten den 9 juni 2008 och släpptes med Mac OS X 10.6 den 28 augusti 2009. [3]

Den 5 april 2009 tillkännagav AMD tillgängligheten för nedladdning av betaversionen av ATI Stream SDK v2.0, som inkluderar OpenCL-multiprocessorprogrammeringsspråket.

Den 20 april 2009 släppte nVidia en betadrivrutin och mjukvaruutvecklingskit ( SDK ) med stöd för den öppna GPGPU-standarden OpenCL. Denna beta-drivrutin är avsedd för utvecklare som deltar i OpenCL Early Access-programmet, som kan delta i betatestet från och med den 20 april. För GPU Computing Registered Developers-medlemmar kommer en betaversion av OpenCL-drivrutinen att göras tillgänglig vid ett senare tillfälle. [4] [5] [6]

Den 26 november 2009 släppte nVidia en drivrutin som stöder OpenCL 1.0 (rev 48).

För en visuell representation av hur OpenCL-tekniken använder kapaciteten hos ett 24-kärnsystem för att rendera videoeffekter, rekommenderas det att titta på följande demo: [1] Arkiverad 9 mars 2017 på Wayback Machine .

OpenCL 1.1 introducerades av Khronos Group den 14 juni 2010 . Den nya versionen utökar avsevärt funktionaliteten för parallell programmering, flexibilitet och prestanda, och lägger till nya funktioner.

OpenCL 1.2 introducerades den 15 november 2011 . Den nya versionen innehåller många små förbättringar relaterade till ökad språkflexibilitet och prestandaoptimeringar. OpenCL 1.2 lade till ett antal betydande innovationer.

OpenCL 2.0 introducerades den 22 juli 2013 [7] och standardiserades den 18 november samma år [8] .

OpenCL 2.1 introducerades den 3 mars 2015 och standardiserades den 16 november samma år. Den skrev om kärnan från C till C++14 .

OpenCL 3.0 introducerades den 27 april 2020 [9] och standardiserades den 30 september samma år [10] . Noterbara förändringar inkluderar att OpenCL 3.0 API nu täcker alla versioner av OpenCL (1.2, 2.x), utan att tillhandahålla separata specifikationer för varje version.

Händelser

Funktioner i språket

De viktigaste skillnaderna mellan det använda språket och C (1999 ISO-standard) är:

Exempel

FFT- beräkningsexempel : [13]

// att skapa en datorkontext för GPU- kontexten (videokort) = clCreateContextFromType ( NULL , CL_DEVICE_TYPE_GPU , NULL , NULL , NULL ); // skapa en kommandokö kö = clCreateCommandQueue ( kontext , NULL , 0 , NULL ); // minnesallokering i form av buffertar memobjs [ 0 ] = clCreateBuffer ( kontext , CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR , sizeof ( float ) * 2 * num_entries , srcA , NULL ; memobjs [ 1 ] = clCreateBuffer ( kontext , CL_MEM_READ_WRITE , sizeof ( float ) * 2 * num_entries , NULL , NULL ); // skapa ett program från källprogrammet = clCreateProgramWithSource ( context , 1 , & fft1D_1024_kernel_src , NULL , NULL ); // kompilera programmet clBuildProgram ( program , 0 , NULL , NULL , NULL , NULL ); // skapa ett kärnobjekt från en kompilerad programkärna = clCreateKernel ( program , " fft1D_1024 " , NULL ); // förbered argument clSetKernelArg ( kärna , 0 , sizeof ( cl_mem ), ( void * ) & memobjs [ 0 ]); clSetKernelArg ( kärna , 1 , sizeof ( cl_mem ), ( void * ) & memobjs [ 1 ]); clSetKernelArg ( kärna , 2 , sizeof ( float ) * ( local_work_size [ 0 ] + 1 ) * 16 , NULL ); clSetKernelArg ( kärna , 3 , sizeof ( float ) * ( local_work_size [ 0 ] + 1 ) * 16 , NULL ); // ställa in ND-intervallet med arbetsobjektdimensioner och skicka det till exekveringskön global_work_size [ 0 ] = antal_poster ; local_work_size [ 0 ] = 64 ; clEnqueueNDRangeKernel ( kö , kärna , 1 , NULL , global_work_size , local_work_size , 0 , NULL , NULL );

Direkta beräkningar (baserade på att FFT anpassas till G80-arkitekturrapporten) [14] :

// Denna kod beräknar FFT av längd 1024 genom att dela upp den i 16, 16 och 4 __kärna void fft1D_1024 ( __global float2 * in , __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 ] ; // adress för början av den bearbetade datan i globalt minne i = in + blockIdx ; ut = ut + blockIdx ; globalLoads ( data , in , 64 ); // sammanslagna globala läser fftRadix16Pass ( data ); // in-place radix-16 pass twiddleFactorMul ( data , tid , 1024 , 0 ); // lokal blandning med lokalt minne localShuffle ( data , sMemx , sMemy , tid , ((( tid & 15 ) * 65 ) + ( tid >> 4 ))); fftRadix16Pass ( data ); // in-place radix-16 pass twiddleFactorMul ( data , tid , 64 , 4 ); // twiddle factor multiplikation localShuffle ( data , sMemx , sMemy , tid , ((( tid >> 4 ) * 64 ) + ( tid & 15 ))); // 4 FFT-anrop av order 4 fftRadix4Pass ( data ); // radix-4 funktion nummer 1 fftRadix4Pass ( data + 4 ); // radix-4 funktion nummer 2 fftRadix4Pass ( data + 8 ); // radix-4 funktion nummer 3 fftRadix4Pass ( data + 12 ); // radix-4 funktion nummer 4 // coalesced global skriver globalStores ( data , ut , 64 ); }

En fullständig implementering av FFT i OpenCL finns tillgänglig på Apples webbplats [15] .

Applikation

OpenCL används, som en av implementeringarna av det allmänna GPU- konceptet , i olika programvaror.

  • WinZip v16.5 ( 2012 ) från Corel  - förutom den uppdaterade motorn för att förbättra dess optimering för flerkärniga processorer, har OpenCL-stöd lagts till för AMD GPU:er (dock inte för Intel och Nvidia) - samtidigt som prestanda ökar i denna tillämpning på Trinity och Llano APU var upp till 45 %. [16]

Se även

Anteckningar

  1. ↑ AMD driver antagande av industristandarder i GPGPU-programvaruutveckling . AMD. Arkiverad från originalet den 19 mars 2012.
  2. ↑ AMD stöder OpenCL, Microsoft DirectX 11 . eWeek. Arkiverad från originalet den 19 mars 2012.
  3. ↑ Apple förhandsgranskar Mac OS X Snow Leopard för utvecklare . Äpple. Arkiverad från originalet den 19 mars 2012.
  4. ↑ Andrew Humber. NVIDIA släpper OpenCL-drivrutin till  utvecklare . NVIDIA (20 april 2009). - Originalnyheter på den officiella webbplatsen för NVIDIA Corporation. Hämtad 21 april 2009. Arkiverad från originalet 19 mars 2012.
  5. ↑ Pavel Shubsky. NVIDIA har öppnat GPGPU för utvecklare under OpenCL (inte tillgänglig länk) . Igromania (tidskrift) (21 april 2009). Hämtad 21 april 2009. Arkiverad från originalet 25 april 2009. 
  6. ↑ Sergey och Marina Bondarenko. OpenCL-drivrutin för utvecklare från NVIDIA . 3DNews (21 april 2009). Hämtad 21 april 2009. Arkiverad från originalet 23 april 2009.
  7. ↑ Khronos släpper OpenCL  2.0 . khronos.org (22 juli 2013). Hämtad 22 juli 2013. Arkiverad från originalet 17 augusti 2013.
  8. ↑ Khronos slutför OpenCL 2.0 Specification for Heterogeneous Computing , Khronos Group  ( 18 november 2013). Arkiverad 11 november 2020. Hämtad 20 november 2013.
  9. ↑ Khronos Group släpper OpenCL 3.0 provisoriska specifikationer  . Khronos Group (27 april 2020). Hämtad 27 april 2020. Arkiverad från originalet 18 januari 2021.
  10. ↑ OpenCL 3.0-specifikation slutförd och initial Khronos Open Source OpenCL SDK  släppt . Khronos Group (30 september 2020). Hämtad 30 september 2020. Arkiverad från originalet 30 september 2020.
  11. ↑ 1 2 3 Implementering av WebCL-teknologi presenterad för WebKit . opennet.ru (4 juli 2011). Hämtad 31 oktober 2011. Arkiverad från originalet 18 maj 2012.
  12. ↑ 12 AMD . Introduktion till OpenCL-programmering 201005, sid 89-90
  13. ↑ OpenCL . SIGGRAPH2008 (14 augusti 2008). Hämtad 14 augusti 2008. Arkiverad från originalet 19 mars 2012.
  14. ↑ Montera FFT på G80 Architecture (PDF). Vasily Volkov och Brian Kazian, UC Berkeley CS258 projektrapport (maj 2008). Hämtad 14 november 2008. Arkiverad från originalet 19 mars 2012.
  15. ↑ . OpenCL på FFT (inte tillgänglig länk) . Apple (16 november 2009). Hämtad 7 december 2009. Arkiverad från originalet 30 november 2009. 
  16. ↑ AMD Trinity Benchmarks - OpenCL Arkiverad 29 augusti 2012 på Wayback Machine // THG

Litteratur

  • Aaftab Munshi; Benedict R. Gaster; Timothy G. Mattson; James Fung; Dan Ginsburg. OpenCL programmeringsguide. - Addison-Wesley Professional, 2011. - 648 sid. — ISBN 978-0-321-74964-2 .

Länkar

 Khronos-gruppens standarder
Aktiva
Inaktiv