OpenCL
| OpenCL | ||
|---|---|---|
| Teil des heterogenen Rechnens | ||
 | ||
 | ||
| Allgemeine Information | ||
| Programmtyp | Anwendungsprogrammierschnittstelle , GPGPU | |
| Autor | Manzana | |
| Entwickler | Kronos-Gruppe | |
| Erstveröffentlichung | 28. August 2009 | |
| Lizenz | Gebührenfrei | |
| Technische Information | ||
| Eingeplant | ||
| Unterstützte Plattformen | ||
| Versionen | ||
| Neueste stabile Version | 3.0 [ 1 ] ( info ) ( 27. April 2020 (2 Jahre, 5 Monate und 21 Tage) [ 1 ] ) | |
| Verknüpfungen | ||
OpenCL ( Open Computing Language ) besteht aus einer Anwendungsprogrammierschnittstelle und einer Programmiersprache . Zusammen ermöglichen sie die Erstellung von Anwendungen mit Parallelität auf Daten- und Aufgabenebene, die sowohl auf Zentraleinheiten als auch auf Grafikeinheiten laufen können . Die Sprache basiert auf C99 , entfernt einige Funktionen und erweitert sie um Vektoroperationen. [ 2 ]
Die ursprüngliche Spezifikation wurde von Apple erstellt und in Zusammenarbeit mit AMD , IBM , Intel und NVIDIA entwickelt . Apple schlug es der Khronos Group vor, es zu einem offenen, lizenzfreien Standard zu machen. Am 16. Juni 2008 gründete Khronos die Compute Working Group [ 3 ] , um den Standardisierungsprozess durchzuführen. 2013 wurde die Version 2.0 des Standards veröffentlicht.
OpenCL ist Teil von Mac OS X v10.6 ('Snow Leopard'), [ 4 ] während AMD sich entschieden hat, OpenCL anstelle seiner alten Close-to-Metal -API zu unterstützen . [ 5 ] [ 6 ] Intel hat auch eine eigene Entwicklungsumgebung und NVIDIA unterstützt neben einer eigenen API für Grafikchips namens CUDA auch OpenCL.
Beispiel
Dieses Beispiel berechnet eine schnelle Fourier-Transformation . [ 2 ] Die API-Aufrufe lauten wie folgt:
// Compute-Kontext mit GPU-Gerätekontext erstellen
= clCreateContextFromType ( CL_DEVICE_TYPE_GPU ) ;
// eine Arbeitswarteschlange erstellen
= clCreateWorkQueue ( context , NULL , NULL , 0 ) ;
// die Pufferspeicherobjekte zuweisen
memobjs [ 0 ] = clCreateBuffer ( context , CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR , sizeof ( float ) * 2 * num_entries , srcA );
memobjs [ 1 ] = clCreateBuffer ( Kontext , CL_MEM_READ_WRITE , sizeof ( float ) * 2 * num_entries , NULL );
// Berechnungsprogramm erstellen
program = clCreateProgramFromSource ( context , 1 , & fft1D_1024_kernel_src , NULL );
// Erstellen der ausführbaren Datei des
Rechenprogramms clBuildProgramExecutable ( program , false , NULL , NULL );
// Rechenkern erstellen
kernel = clCreateKernel ( program , „ fft1D_1024 “ );
// ND-Bereichsobjekt mit Arbeitselementabmessungen erstellen
global_work_size [ 0 ] = n ;
local_work_size [ 0 ] = 64 ;
range = clCreateNDRangeContainer ( Kontext , 0 , 1 , globale_Arbeitsgröße , lokale_Arbeitsgröße );
// setze die
Argumentwerte clSetKernelArg ( kernel , 0 , ( void * ) & memobjs [ 0 ], sizeof ( cl_mem ), NULL );
clSetKernelArg ( Kernel , 1 , ( void * ) & memobjs [ 1 ], sizeof ( cl_mem ), NULL );
clSetKernelArg ( kernel , 2 , NULL , sizeof ( float ) * ( local_work_size [ 0 ] + 1 ) * 16 , NULL );
clSetKernelArg ( kernel , 3 , NULL , sizeof ( float ) * ( local_work_size [ 0 ] + 1 ) * 16 , NULL );
// Kernel ausführen
clExecuteKernel ( Warteschlange , Kernel , NULL , Bereich , NULL , 0 , NULL );
Die Berechnung selbst ist diese:
// Dieser Kernel berechnet FFT der Länge 1024. Die FFT der Länge 1024 wird zerlegt in
// Aufrufe einer Radix-16-Funktion, einer weiteren Radix-16-Funktion und dann einer Radix-4-Funktion
__kernel 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 ; Float2 -Daten [ 16 ]; // Anfangsindex der Daten zum/vom globalen Speicher in = in + blockIdx ; aus = aus + blockIdx ; globalLoads ( Daten , in , 64 ); // verschmolzene globale Lesevorgänge fftRadix16Pass ( data ); // in-place radix-16 pass twiddleFactorMul ( data , tid , 1024 , 0 ); // lokaler Shuffle mit lokalem Speicher localShuffle ( data , sMemx , sMemy , tid , ((( tid & 15 ) * 65 ) + ( tid >> 4 ))); fftRadix16Pass ( Daten ); // in-place radix-16 pass twiddleFactorMul ( data , tid , 64 , 4 ); // Twiddle-Faktor-Multiplikation localShuffle ( data , sMemx , sMemy , tid , ((( tid >> 4 ) * 64 ) + ( tid & 15 ))); // vier Radix-4-Funktionsaufrufe fftRadix4Pass ( data ); fftRadix4Pass ( Daten + 4 ); fftRadix4Pass ( Daten + 8 ); fftRadix4Pass ( Daten + 12 ); // koaleszierte globale Schreibvorgänge globalStores ( data , out , 64 ); }
Siehe auch
- GPGPU
- KUDA
- nah an Metall
- BrookGPU
- Lib Sh
- Larrabee (GPU)
Referenzen
- ↑ a b Khronos veröffentlicht OpenCL 3.0
- ^ a b "OpenCL" . SIGGRAPH2008. 14. August 2008. Archiviert vom Original am 19. März 2012 . Abgerufen am 14. August 2008 .
- ^ "Khronos startet heterogene Computing-Initiative" . Chronos-Gruppe. 16. Juni 2008. Archiviert vom Original am 20. Juni 2008 . Abgerufen am 18. Juni 2008 .
- ↑ „Apple gibt Entwicklern eine Vorschau auf Mac OS X Snow Leopard“ . Manzana. 9. Juni 2008. Archiviert vom Original am 11. Juni 2008 . Abgerufen am 9. Juni 2008 .
- ^ "AMD fördert die Übernahme von Industriestandards in der GPGPU-Softwareentwicklung" . AMD. 6. August 2008. Archiviert vom Original am 16. September 2008 . Abgerufen am 14. August 2008 .
- ^ "AMD unterstützt OpenCL, Microsoft DirectX 11" . eWoche. 6. August 2008. Archiviert vom Original am 19. März 2012 . Abgerufen am 14. August 2008 .
