OpenCL - OpenCL

OpenCL API

Originale forfattere	Apple Inc.
Udvikler (er)	Khronos Group
Første udgivelse	28. august 2009 ; 12 år siden ( 2009-08-28 )
Stabil udgivelse	3.0 / 30. september 2020 ; 12 måneder siden ( 2020-09-30 )
Skrevet i	C med C ++ bindinger
Operativ system	Android (leverandørafhængig), FreeBSD , Linux , macOS (via Pocl), Windows
Platform	ARMv7 , ARMv8 , Cell , IA-32 , POWER , x86-64
Type	Heterogen computing API
Licens	OpenCL -specifikationslicens
Internet side	www .khronos .org /opencl /

OpenCL ( Open Computing Language ) er en ramme for skrivning af programmer, der udføres på tværs af heterogene platforme bestående af centrale processorenheder (CPU'er), grafikprocessorenheder (GPU'er), digitale signalprocessorer (DSP'er), feltprogrammerbare gate-arrays (FPGA'er) og andre processorer eller hardware acceleratorer . OpenCL angiver programmeringssprog (baseret på C99 , C ++ 14 og C ++ 17 ) til programmering af disse enheder og applikationsprogrammeringsgrænseflader (API'er) til at styre platformen og udføre programmer på computerenhederne . OpenCL giver en standardgrænseflade til parallel computing ved hjælp af opgave- og databaseret parallelisme .

OpenCL er en åben standard, der opretholdes af det nonprofit- teknologiske konsortium Khronos Group . Konforme implementeringer er tilgængelige fra Altera , AMD , ARM , Creative , IBM , Imagination , Intel , Nvidia , Qualcomm , Samsung , Vivante , Xilinx og ZiiLABS .

Oversigt

OpenCL ser et computersystem som bestående af et antal computerenheder , som kan være centrale processorenheder (CPU'er) eller "acceleratorer" såsom grafikprocessorenheder (GPU'er), der er knyttet til en værtsprocessor (en CPU). Det definerer et C-lignende sprog til at skrive programmer. Funktioner, der udføres på en OpenCL -enhed, kaldes " kerner ". En enkelt beregningsindretning består typisk af flere computerenheder , som igen omfatter flere behandlingselementer (PE'er). En enkelt kerneudførelse kan køre på alle eller mange af PE'erne parallelt. Hvordan en beregningsenhed er opdelt i beregningsenheder og PE'er er op til sælgeren; en beregningsenhed kan betragtes som en " kerne ", men begrebet kerne er svært at definere på tværs af alle typer enheder, der understøttes af OpenCL (eller endda inden for kategorien "CPU'er"), og antallet af beregningsenheder kan svarer ikke til antallet af kerner, der påstås i sælgeres marketinglitteratur (som faktisk kan tælle SIMD -baner ).

Ud over sit C-lignende programmeringssprog definerer OpenCL en applikationsprogrammeringsgrænseflade (API), der tillader programmer, der kører på værten, at starte kerner på computerenhederne og styre enhedshukommelse, som (i det mindste konceptuelt) er adskilt fra værtshukommelsen. Programmer på OpenCL-sproget er beregnet til at blive kompileret i løbetid , så OpenCL-brugende applikationer er bærbare mellem implementeringer til forskellige værtenheder. OpenCL -standarden definerer vært -API'er for C og C ++ ; tredjeparts-API'er findes til andre programmeringssprog og platforme, såsom Python , Java , Perl , D og .NET . En implementering af OpenCL -standarden består af et bibliotek, der implementerer API'en for C og C ++ og en OpenCL C -kompilator til beregningsenheden (e), der er målrettet.

For at åbne OpenCL-programmeringsmodellen til andre sprog eller for at beskytte kernelkilden mod inspektion, kan Standard Portable Intermediate Representation (SPIR) bruges som en måluafhængig måde til at sende kerner mellem en front-end-kompilator og OpenCL-bagsiden -ende.

For nylig har Khronos Group ratificeret SYCL , en programmeringsmodel på højere niveau for OpenCL som en enkelt kilde DSEL baseret på ren C ++ 17 for at forbedre programmeringsproduktiviteten . Derudover kan C ++ - funktioner også bruges til implementering af computerkernekilder i C ++ til OpenCL -sprog.

Hukommelseshierarki

OpenCL definerer et hukommelseshierarki på fire niveauer for computerenheden:

• global hukommelse: deles af alle behandlingselementer, men har høj adgangstid ( __global );
• skrivebeskyttet hukommelse: mindre, lav latenstid, skrivbar af værts-CPU'en, men ikke beregningsenhederne ( __constant );
• lokal hukommelse: delt af en gruppe behandlingselementer ( __local );
• per-element privat hukommelse ( registre ; __private ).

Ikke alle enheder behøver at implementere hvert niveau i dette hierarki i hardware. Konsistensen mellem de forskellige niveauer i hierarkiet lempes og håndhæves kun af eksplicitte synkroniseringskonstruktioner , især barrierer .

Enheder deler muligvis hukommelse med værts -CPU'en. Værts -API'en giver håndtag på enhedshukommelsesbuffere og funktioner til at overføre data frem og tilbage mellem vært og enheder.

OpenCL -kernesprog

Det programmeringssprog, der bruges til at skrive beregnede kerner , kaldes kernelsprog. OpenCL vedtager C / C ++ -baserede sprog for at specificere de kerneberegninger, der udføres på enheden med nogle begrænsninger og tilføjelser for at lette effektiv kortlægning til acceleratorernes heterogene hardware -ressourcer. Traditionelt blev OpenCL C brugt til at programmere acceleratorerne i OpenCL -standard, senere blev C ++ til OpenCL -kernesprog udviklet, der arvede al funktionalitet fra OpenCL C, men fik lov til at bruge C ++ - funktioner i kernekilderne.

OpenCL C sprog

OpenCL C er en C99 -baseret sprogdialekt tilpasset til at passe til enhedsmodellen i OpenCL. Hukommelsesbuffere findes i bestemte niveauer i hukommelseshierarkiet , og pointer er annoteret med regionskvalifikatorerne __global , __local , __constant og __private , hvilket afspejler dette. I stedet for en indretning program har en main funktion, er OpenCL C-funktioner markeret __kernel at signalere, at de er indgange i programmet at blive kaldt fra værten program. Funktionspointere , bitfelter og variabel længde arrays er udeladt, og rekursion er forbudt. Den libc erstattes af en brugerdefineret sæt af standard funktioner, rettet mod matematik programmering.

OpenCL C udvides til at lette brugen af parallelisme med vektortyper og operationer, synkronisering og funktioner til at arbejde med arbejdsemner og arbejdsgrupper. Især udover skalartyper som float og double , der opfører sig på samme måde som de tilsvarende typer i C, leverer OpenCL vektortyper med fast længde, såsom float4 (4-vektor af single-precision floats); sådanne vektortyper er tilgængelige i længderne to, tre, fire, otte og seksten for forskellige basetyper. Vektoriserede operationer på disse typer er beregnet til at kortlægge til SIMD -instruktionssæt, f.eks. SSE eller VMX , når der køres OpenCL -programmer på CPU'er. Andre specialiserede typer omfatter 2-d og 3-d billedtyper.

Eksempel: matrix-vektor multiplikation

Hver påkaldelse ( arbejdspost ) i kernen tager en række af den grønne matrix ( A i koden), multiplicerer denne række med den røde vektor ( x ) og placerer resultatet i en indtastning af den blå vektor ( y ). Antallet af kolonner n overføres til kernen som ncols ; antallet af rækker er implicit i antallet af arbejdsemner, der produceres af værtsprogrammet.

Følgende er en matrix-vektor multiplikationsalgoritme i OpenCL C.

// Multiplies A*x, leaving the result in y.
// A is a row-major matrix, meaning the (i,j) element is at A[i*ncols+j].
__kernel void matvec(__global const float *A, __global const float *x,
                     uint ncols, __global float *y)
{
    size_t i = get_global_id(0);              // Global id, used as the row index
    __global float const *a = &A[i*ncols];    // Pointer to the i'th row
    float sum = 0.f;                          // Accumulator for dot product
    for (size_t j = 0; j < ncols; j++) {
        sum += a[j] * x[j];
    }
    y[i] = sum;
}

Kernefunktionsparametrene matvec beregner i hvert påkaldelse, det prikproduktet af en enkelt række af en matrix A og en vektor x :

${\ displaystyle y_ {i} = a_ {i,:} \ cdot x = \ sum _ {j} a_ {i, j} x_ {j}}$.

For at udvide dette til en fuld matrix-vektor multiplikation, kortlægger OpenCL-runtime kernen over matrixens rækker. På værtsiden gør clEnqueueNDRangeKernel -funktionen dette; det tager som argumenter kernen til at udføre, sine argumenter, og en række arbejds-poster, der svarer til antallet af rækker i matricen A .

Eksempel: beregning af FFT

Dette eksempel indlæser en hurtig Fourier transform (FFT) implementering og udfører den. Implementeringen er vist nedenfor. Koden beder OpenCL-biblioteket om det første tilgængelige grafikkort, opretter hukommelsesbuffere til læsning og skrivning (fra grafikkortets perspektiv), JIT-kompilerer FFT-kernen og kører til sidst asynkront kernen. Resultatet fra transformationen læses ikke i dette eksempel.

#include <stdio.h>
#include <time.h>
#include "CL/opencl.h"

#define NUM_ENTRIES 1024

int main() // (int argc, const char* argv[])
{
	// CONSTANTS
	// The source code of the kernel is represented as a string
	// located inside file: "fft1D_1024_kernel_src.cl". For the details see the next listing.
	const char *KernelSource =
		#include "fft1D_1024_kernel_src.cl"
			;

	// Looking up the available GPUs
	const cl_uint num = 1;
	clGetDeviceIDs(NULL, CL_DEVICE_TYPE_GPU, 0, NULL, (cl_uint*)&num);

	cl_device_id devices[1];
	clGetDeviceIDs(NULL, CL_DEVICE_TYPE_GPU, num, devices, NULL);

	// create a compute context with GPU device
	cl_context context = clCreateContextFromType(NULL, CL_DEVICE_TYPE_GPU, NULL, NULL, NULL);

	// create a command queue
	clGetDeviceIDs(NULL, CL_DEVICE_TYPE_DEFAULT, 1, devices, NULL);
	cl_command_queue queue = clCreateCommandQueue(context, devices[0], 0, NULL);

	// allocate the buffer memory objects
	cl_mem memobjs[] = { clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(float) * 2 * NUM_ENTRIES, NULL, NULL),
						 clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(float) * 2 * NUM_ENTRIES, NULL, NULL) };
	// cl_mem memobjs[0] = // FIXED, SEE ABOVE
	// cl_mem memobjs[1] = // FIXED, SEE ABOVE

	// create the compute program
	// const char* fft1D_1024_kernel_src[1] = {  };
	cl_program program = clCreateProgramWithSource(context, 1, (const char **)& KernelSource, NULL, NULL);

	// build the compute program executable
	clBuildProgram(program, 0, NULL, NULL, NULL, NULL);

	// create the compute kernel
	cl_kernel kernel = clCreateKernel(program, "fft1D_1024", NULL);

	// set the args values

	size_t local_work_size[1] = { 256 };

	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);

	// create N-D range object with work-item dimensions and execute kernel
	size_t global_work_size[1] = { 256 };
	
	global_work_size[0] = NUM_ENTRIES;
	local_work_size[0] = 64; //Nvidia: 192 or 256
	clEnqueueNDRangeKernel(queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
}

Den faktiske beregning inde i filen "fft1D_1024_kernel_src.cl" (baseret på Fitting FFT på G80 -arkitekturen ):

R"(
  // This kernel computes FFT of length 1024. The 1024 length FFT is decomposed into
  // calls to a radix 16 function, another radix 16 function and then a radix 4 function

  __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 data[16];

    // starting index of data to/from global memory
    in = in + blockIdx;  out = out + blockIdx;

    globalLoads(data, in, 64); // coalesced global reads
    fftRadix16Pass(data);      // in-place radix-16 pass
    twiddleFactorMul(data, tid, 1024, 0);

    // local shuffle using local memory
    localShuffle(data, sMemx, sMemy, tid, (((tid & 15) * 65) + (tid >> 4)));
    fftRadix16Pass(data);               // in-place radix-16 pass
    twiddleFactorMul(data, tid, 64, 4); // twiddle factor multiplication

    localShuffle(data, sMemx, sMemy, tid, (((tid >> 4) * 64) + (tid & 15)));

    // four radix-4 function calls
    fftRadix4Pass(data);      // radix-4 function number 1
    fftRadix4Pass(data + 4);  // radix-4 function number 2
    fftRadix4Pass(data + 8);  // radix-4 function number 3
    fftRadix4Pass(data + 12); // radix-4 function number 4

    // coalesced global writes
    globalStores(data, out, 64);
  }
)"

En fuld open source -implementering af en OpenCL FFT findes på Apples websted.

C ++ til OpenCL -sprog

I 2020 annoncerede Khronos overgangen til det community -driven C ++ for OpenCL programmeringssprog, der giver funktioner fra C ++ 17 i kombination med de traditionelle OpenCL C -funktioner. Dette sprog gør det muligt at udnytte en lang række sprogfunktioner fra standard C ++ og samtidig bevare bagudkompatibilitet til OpenCL C. Dette åbner en jævn overgangssti til C ++ - funktionalitet for OpenCL -kernekodeudviklerne, da de kan fortsætte med at bruge velkendt programmeringsflow og endda værktøjer som samt udnytte eksisterende udvidelser og biblioteker til rådighed for OpenCL C.

Sprogsemantikken er beskrevet i den dokumentation, der er offentliggjort i udgivelserne af OpenCL-Docs-depot, der er vært for Khronos-gruppen, men den er i øjeblikket ikke ratificeret af Khronos-gruppen. C ++ til OpenCL-sproget er ikke dokumenteret i et enkeltstående dokument, og det er baseret på specifikationen for C ++ og OpenCL C. Open source Clang- kompilatoren har understøttet C ++ for OpenCL siden udgivelse 9.

C ++ til OpenCL er oprindeligt udviklet som en Clang-kompilatorudvidelse og dukkede op i udgivelsen 9. Da den var tæt forbundet med OpenCL C og ikke indeholdt nogen Clang-specifik funktionalitet, er dens dokumentation blevet hostet til OpenCL-Docs-depotet fra Khronos Group sammen med kilderne til andre specifikationer og referencekort. Den første officielle udgivelse af dette dokument, der beskriver C ++ til OpenCL version 1.0, er blevet offentliggjort i december 2020. C ++ til OpenCL 1.0 indeholder funktioner fra C ++ 17, og det er bagudkompatibelt med OpenCL C 2.0. Et igangværende udkast til dets dokumentation kan findes på Khronos websted.

Funktioner

C ++ til OpenCL understøtter de fleste funktioner (syntaktisk og semantisk) fra OpenCL C bortset fra indlejret parallelisme og blokke. Der er imidlertid mindre forskelle i nogle understøttede funktioner, der hovedsageligt er relateret til forskelle i semantik mellem C ++ og C. F.eks. Er C ++ mere strenge med de implicitte typekonverteringer, og det understøtter ikke begrænsningstypekvalifikatoren . Følgende C ++-funktioner understøttes ikke af C ++ for OpenCL: virtuelle funktioner, dynamic_cast- operatør, ikke-placering af nye / slette operatører, undtagelser, markør til medlemsfunktioner, referencer til funktioner, C ++-standardbiblioteker. C ++ til OpenCL udvider konceptet med separate hukommelsesområder ( adresserum ) fra OpenCL C til C ++ - funktioner - funktionelle casts, skabeloner, klassemedlemmer, referencer, lambda -funktioner, operatorer. De fleste C ++ - funktioner er ikke tilgængelige for kernefunktionerne, f.eks. Overbelastning eller skabelon, vilkårligt klasselayout i parametertype.

Eksempel: kompleks talregning

Det følgende kodestykke illustrerer, hvordan kerner med kompleks talregning kan implementeres i C ++ for OpenCL -sprog med praktisk brug af C ++ - funktioner.

// Define a class Complex, that can perform complex number computations with
// various precision when different types for T are used - double, float, half.
template<typename T>
class complex_t {
T m_re; // Real component.
T m_im; // Imaginary component.

public:
complex_t(T re, T im): m_re{re}, m_im{im} {};
// Define operator for complex number multiplication.
complex_t operator*(const complex_t &other) const
{
  return {m_re * other.m_re - m_im * other.m_im,
           m_re * other.m_im + m_im * other.m_re};
}
int get_re() const { return m_re; }
int get_im() const { return m_im; }
};

// A helper function to compute multiplication over complex numbers read from
// the input buffer and to store the computed result into the output buffer.
template<typename T>
void compute_helper(__global T *in, __global T *out) {
  auto idx = get_global_id(0);    
  // Every work-item uses 4 consecutive items from the input buffer
  // - two for each complex number.
  auto offset = idx * 4;
  auto num1 = complex_t{in[offset], in[offset + 1]};
  auto num2 = complex_t{in[offset + 2], in[offset + 3]};
  // Perform complex number multiplication.
  auto res = num1 * num2;
  // Every work-item writes 2 consecutive items to the output buffer.
  out[idx * 2] = res.get_re();
  out[idx * 2 + 1] = res.get_im();
}

// This kernel is used for complex number multiplication in single precision.
__kernel void compute_sp(__global float *in, __global float *out) {
  compute_helper(in, out);
}

#ifdef cl_khr_fp16
// This kernel is used for complex number multiplication in half precision when
// it is supported by the device.
#pragma OPENCL EXTENSION cl_khr_fp16: enable
__kernel void compute_hp(__global half *in, __global half *out) {
  compute_helper(in, out); 
}
#endif

Værktøjs- og udførelsesmiljø

C ++ til OpenCL -sprog kan bruges til de samme applikationer eller biblioteker og på samme måde som OpenCL C -sprog bruges. På grund af det store udvalg af C ++ sprogfunktioner kan applikationer skrevet i C ++ til OpenCL udtrykke kompleks funktionalitet mere bekvemt end applikationer skrevet i OpenCL C og især er det generiske programmeringsparadigme fra C ++ meget attraktivt for bibliotekets udviklere.

C ++ til OpenCL -kilder kan kompileres af OpenCL -drivere, der understøtter udvidelsen cl_ext_cxx_for_opencl . Arm har annonceret støtte til denne udvidelse i december 2020. På grund af den stigende kompleksitet af algoritmerne, der accelereres på OpenCL -enheder, forventes det, at flere applikationer vil kompilere C ++ til OpenCL -kerner offline ved hjælp af enkeltstående kompilatorer som Clang til eksekverbart binært format eller bærbart binært format f.eks. SPIR-V. Sådan en eksekverbar fil kan indlæses under OpenCL -applikationsudførelsen ved hjælp af en dedikeret OpenCL API.

Binarier udarbejdet fra kilder i C ++ til OpenCL 1.0 kan eksekveres på OpenCL 2.0 -kompatible enheder. Afhængigt af de sprogfunktioner, der bruges i sådanne kernekilder, kan den også eksekveres på enheder, der understøtter tidligere OpenCL -versioner eller OpenCL 3.0.

Bortset fra OpenCL -drivere kan kerner skrevet i C ++ til OpenCL kompileres til udførelse på Vulkan -enheder ved hjælp af clspv -kompilator og clvk -runtime -lag på samme måde som OpenCL C -kerner.

Bidrag

C ++ til OpenCL er et åbent sprog udviklet af fællesskabet af bidragydere, der er angivet i dokumentationen. Nye bidrag til sprogsemantisk definition eller open source værktøjsstøtte accepteres fra alle interesserede, så snart de er tilpasset hoveddesignfilosofien, og de gennemgås og godkendes af de erfarne bidragsydere.

Historie

OpenCL blev oprindeligt udviklet af Apple Inc. , der har varemærkerettigheder , og forfinet til et første forslag i samarbejde med tekniske teams hos AMD , IBM , Qualcomm , Intel og Nvidia . Apple forelagde dette første forslag for Khronos Group . Den 16. juni 2008 blev Khronos Compute Working Group dannet med repræsentanter fra CPU-, GPU-, embedded-processor- og softwarevirksomheder. Denne gruppe arbejdede i fem måneder med at færdiggøre de tekniske detaljer i specifikationen for OpenCL 1.0 senest den 18. november 2008. Denne tekniske specifikation blev gennemgået af Khronos -medlemmerne og godkendt til offentliggørelse den 8. december 2008.

OpenCL 1.0

OpenCL 1.0 udgivet med Mac OS X Snow Leopard den 28. august 2009. Ifølge en Apple -pressemeddelelse:

Snow Leopard udvider yderligere understøttelse af moderne hardware med Open Computing Language (OpenCL), som lader enhver applikation udnytte de enorme gigaflops af GPU -computerkraft, der tidligere kun var tilgængelig for grafikapplikationer. OpenCL er baseret på programmeringssproget C og er blevet foreslået som en åben standard.

AMD besluttede at understøtte OpenCL i stedet for den nu udfasede Close to Metal i sin Stream -ramme . RapidMind annoncerede deres vedtagelse af OpenCL under deres udviklingsplatform for at understøtte GPU'er fra flere leverandører med en grænseflade. Den 9. december 2008 meddelte Nvidia sin hensigt at tilføje fuld support til OpenCL 1.0 -specifikationen til sit GPU Computing Toolkit. Den 30. oktober 2009 udgav IBM sin første OpenCL -implementering som en del af XL -kompilatorer .

Acceleration af beregninger med faktor til 1000 er mulig med OpenCL i grafikkort mod normal CPU. Nogle vigtige funktioner i den næste version af OpenCL er valgfri i 1.0, f.eks. Dobbelt præcision eller halv præcision.

OpenCL 1.1

OpenCL 1.1 blev ratificeret af Khronos Group den 14. juni 2010 og tilføjer betydelig funktionalitet til forbedret parallel programmeringsfleksibilitet, funktionalitet og ydeevne, herunder:

• Nye datatyper, herunder 3-komponentvektorer og yderligere billedformater;
• Håndtering af kommandoer fra flere værtstråde og behandling af buffere på tværs af flere enheder;
• Operationer på regioner i en buffer, herunder læse, skrive og kopiere 1D, 2D eller 3D rektangulære områder;
• Forbedret brug af hændelser til at drive og styre kommandoudførelse;
• Yderligere OpenCL-indbyggede C-funktioner, såsom heltalsklemme, blanding og asynkrone kopier;
• Forbedret OpenGL -interoperabilitet gennem effektiv deling af billeder og buffere ved at forbinde OpenCL- og OpenGL -begivenheder.

OpenCL 1.2

Den 15. november 2011 annoncerede Khronos Group OpenCL 1.2 -specifikationen, som tilføjede betydelig funktionalitet i forhold til de tidligere versioner med hensyn til ydeevne og funktioner til parallel programmering. De mest bemærkelsesværdige funktioner omfatter:

• Enhedspartitionering: muligheden for at opdele en enhed i underenheder, så arbejdsopgaver kan tildeles individuelle beregningsenheder. Dette er nyttigt til at reservere områder på enheden for at reducere latenstid for tidskritiske opgaver.
• Separat kompilering og sammenkædning af objekter: funktionaliteten til at kompilere OpenCL til eksterne biblioteker til inkludering i andre programmer.
• Forbedret billedunderstøttelse (valgfrit): 1.2 tilføjer understøttelse af 1D -billeder og 1D/2D -billedarrays. Desuden tillader OpenGL -delingsudvidelser nu, at OpenGL 1D -teksturer og 1D/2D -teksturarrays kan bruges til at oprette OpenCL -billeder.
• Indbyggede kerner: brugerdefinerede enheder, der indeholder specifik unik funktionalitet, er nu tættere integreret i OpenCL-rammerne. Kerner kan kaldes til at bruge specialiserede eller ikke-programmerbare aspekter af underliggende hardware. Eksempler omfatter videokodning/dekodning og digitale signalprocessorer.
• DirectX -funktionalitet: DX9 deling af medieoverflader muliggør effektiv deling mellem OpenCL og DX9 eller DXVA medieoverflader. Til DX11 er sømløs deling mellem OpenCL og DX11 overflader også mulig.
• Evnen til at tvinge IEEE 754 -overensstemmelse til matematik med enkelt præcisionsflydende punkt: OpenCL som standard gør det muligt for enkeltpræcisionsversionerne af divisionen, gensidig og kvadratrodsoperation at være mindre præcis end de korrekt afrundede værdier, som IEEE 754 kræver. Hvis programmereren sender kommandolinjeargumentet "-cl-fp32-correct-rounded-divide-sqrt" til kompilatoren, vil disse tre operationer blive beregnet til IEEE 754-krav, hvis OpenCL-implementeringen understøtter dette, og det vil undlade at kompilere, hvis OpenCL-implementering understøtter ikke beregning af disse operationer til deres korrekt afrundede værdier som defineret af IEEE 754-specifikationen. Denne evne suppleres med evnen til at forespørge OpenCL -implementeringen for at afgøre, om den kan udføre disse operationer med IEEE 754 -nøjagtighed.

OpenCL 2.0

Den 18. november 2013 annoncerede Khronos -gruppen ratificering og offentliggørelse af den færdige OpenCL 2.0 -specifikation. Opdateringer og tilføjelser til OpenCL 2.0 inkluderer:

• Delt virtuel hukommelse
• Indlejret parallelisme
• Generisk adresserum
• Billeder (valgfrit, inkluderer 3D-billede)
• C11 atom
• Rør
• Udvidelse til klientdriver, der kan installeres på Android
• halv præcision udvidet med valgfri cl_khr_fp16 udvidelse
• cl_double: dobbelt præcision IEEE 754 (valgfri)

OpenCL 2.1

Ratificeringen og frigivelsen af ​​OpenCL 2.1 foreløbige specifikation blev annonceret den 3. marts 2015 på Game Developer Conference i San Francisco. Det blev udgivet den 16. november 2015. Det introducerede OpenCL C ++ kernesproget, baseret på en undersæt af C ++ 14 , samtidig med at understøttelsen af ​​det allerede eksisterende OpenCL C kernesprog opretholdes. Vulkan og OpenCL 2.1 deler SPIR-V som en mellemrepræsentation, der gør det muligt for sprog-front-end på højt niveau at dele et fælles kompilationsmål. Opdateringer til OpenCL API omfatter:

• Yderligere undergruppefunktionalitet
• Kopiering af kerneobjekter og tilstande
• Forespørgsler om timer med lav ventetid
• Indtagelse af SPIR-V-kode efter runtime
• Udførelsesprioritetstip for køer
• Nul størrelse afsendelser fra værten

AMD, ARM , Intel, HPC og YetiWare har erklæret støtte til OpenCL 2.1.

OpenCL 2.2

OpenCL 2.2 bringer OpenCL C ++ kernesproget ind i kernespecifikationen for væsentligt forbedret parallel programmeringsproduktivitet. Den blev udgivet den 16. maj 2017. Vedligeholdelsesopdatering frigivet i maj 2018 med fejlrettelser.

• OpenCL C ++ kernesproget er en statisk delmængde af C ++ 14 standarden og inkluderer klasser, skabeloner, lambda udtryk, funktionsoverbelastninger og mange andre konstruktioner til generisk og metaprogrammering.
• Bruger det nye Khronos SPIR-V 1.1 mellemsprog, der fuldt ud understøtter OpenCL C ++ kernesproget.
• OpenCL-biblioteksfunktioner kan nu bruge C ++-sproget til at give øget sikkerhed og reduceret udefineret adfærd, mens du får adgang til funktioner som atomarer, iteratorer, billeder, samplere, rør og enhedskø-indbyggede typer og adresserum.
• Rørlager er en ny type på siden på enheden i OpenCL 2.2, der er nyttig til FPGA-implementeringer ved at gøre forbindelsesstørrelse og -type kendt på kompileringstidspunktet, hvilket muliggør effektiv kommunikation mellem enheder mellem kerner.
• OpenCL 2.2 indeholder også funktioner til forbedret optimering af genereret kode: applikationer kan levere værdien af ​​specialiseringskonstant ved SPIR-V-kompileringstidspunktet, en ny forespørgsel kan registrere ikke-trivielle konstruktører og destruktorer af programomfang globale objekter, og brugeropkald kan indstilles ved programudgivelsestidspunkt.
• Kører på enhver OpenCL 2.0-kompatibel hardware (kun en driveropdatering er påkrævet).

OpenCL 3.0

OpenCL 3.0 -specifikationen blev frigivet den 30. september 2020 efter at have været i preview siden april 2020. OpenCL 1.2 -funktionalitet er blevet en obligatorisk baseline, mens alle OpenCL 2.x- og OpenCL 3.0 -funktioner blev gjort valgfrie. Specifikationen bevarer OpenCL C-sproget og forælder OpenCL C ++ kernesproget og erstatter det med C ++ for OpenCL-sproget baseret på en Clang / LLVM- kompilator, der implementerer et undersæt af C ++ 17 og SPIR-V mellemkode. Version 3.0.7 af C ++ til OpenCL med nogle Khronos openCL -udvidelser blev præsenteret på IWOCL 21.

Køreplan

Den Internationale Workshop om OpenCL (IWOCL) holdes af gruppen Khronos

Da man frigav OpenCL 2.2, annoncerede Khronos Group, at OpenCL ville konvergere, hvor det var muligt, med Vulkan for at muliggøre fleksibilitet for implementering af OpenCL -software over begge API'er. Dette er nu blevet demonstreret af Adobes Premiere Rush ved hjælp af clspv open source -kompilatoren til at kompilere betydelige mængder OpenCL C -kernekode til at køre på en Vulkan -runtime til implementering på Android. OpenCL har en fremadrettet køreplan uafhængig af Vulkan, med 'OpenCL Next' under udvikling og målrettet frigivelse i 2020. OpenCL Next kan integrere udvidelser som Vulkan / OpenCL Interop, Scratch-Pad Memory Management, Extended Subgroups, SPIR-V 1.4 indtagelse og SPIR-V Udvidet fejlfindingsinformation. OpenCL overvejer også Vulkan-lignende læsser og lag og en 'Fleksibel profil' til implementeringsfleksibilitet på flere acceleratortyper.

Open source -implementeringer

clinfo, et kommandolinjeværktøj til at se OpenCL-oplysninger

OpenCL består af et sæt headers og et delt objekt , der indlæses ved runtime. En installerbar klientdriver (ICD) skal installeres på platformen for hver klasse leverandører, som runtime skal understøtte. Det er for eksempel for at understøtte Nvidia -enheder på en Linux -platform, skulle Nvidia ICD installeres, så OpenCL -runtime (ICD -loader) ville være i stand til at lokalisere ICD'en for leverandøren og omdirigere opkaldene korrekt . Standard OpenCL -header bruges af forbrugerprogrammet; opkald til hver funktion proxies derefter af OpenCL -runtime til den relevante driver ved hjælp af ICD. Hver leverandør skal implementere hvert OpenCL -opkald i deres driver.

Apple, Nvidia, RapidMind og Gallium3D -implementeringerne af OpenCL er alle baseret på LLVM Compiler -teknologien og bruger Clang -kompilatoren som deres frontend.

MESA Gallium Compute

En implementering af OpenCL (faktisk 1.1 ufuldstændig, for det meste udført AMD Radeon GCN ) til en række platforme opretholdes som en del af Gallium Compute Project, som bygger videre på arbejdet i Mesa -projektet til at understøtte flere platforme. Tidligere var dette kendt som CLOVER., Faktisk udvikling: for det meste støtte til at køre ufuldstændige rammer med faktisk LLVM og CLANG, nogle nye funktioner som fp16 i 17.3, Target complete OpenCL 1.0, 1.1 og 1.2 til AMD og Nvidia. Ny grundudvikling udføres af Red Hat med SPIR-V også for Clover. New Target er modulopbygget OpenCL 3.0 med fuld understøttelse af OpenCL 1.2. Faktisk tilstand er tilgængelig i Mesamatrix. Billedstøtter er her i fokus for udviklingen.

BEIGNET

En implementering af Intel til sin Ivy Bridge + hardware blev frigivet i 2013. Denne software fra Intels China Team har tiltrukket kritik fra udviklere på AMD og Red Hat samt Michael Larabel fra Phoronix . Faktisk version 1.3.2 understøtter OpenCL 1.2 komplet (Ivy Bridge og højere) og OpenCL 2.0 valgfri til Skylake og nyere. understøttelse af Android er blevet tilføjet til Beignet., egentlige udviklingsmål: kun support til 1.2 og 2.0, vej til OpenCL 2.1, 2.2, 3.0 er gået til NEO.

NEO

En implementering af Intel til Gen. 8 Broadwell + Gen. 9 hardware frigivet i 2018. Denne driver erstatter Beignet -implementering til understøttede platforme (ikke ældre 6.gen til Haswell). NEO leverer OpenCL 2.1 -understøttelse på Core -platforme og OpenCL 1.2 på Atom -platforme. Faktisk i 2020 understøttes også Graphic Gen 11 Ice Lake og Gen 12 Tiger Lake. Ny OpenCL 3.0 er tilgængelig til Alder Lake, Tiger Lake til Broadwell med version 20.41+. Det inkluderer nu valgfri OpenCL 2.0, 2.1 Funktioner komplet og nogle af 2.2.

ROCm

Oprettet som en del af AMDs GPUOpen , er ROCm (Radeon Open Compute) et open source Linux -projekt bygget på OpenCL 1.2 med sprogunderstøttelse til 2.0. Systemet er kompatibelt med alle moderne AMD -CPU'er og APU'er (faktisk delvist GFX 7, GFX 8 og 9) samt Intel Gen7.5+ CPU'er (kun med PCI 3.0). Med version 1.9 er support på nogle punkter udvidet eksperimentelt til hardware med PCIe 2.0 og uden atomarer. En oversigt over det faktiske arbejde udføres på XDC2018. ROCm Version 2.0 understøtter Full OpenCL 2.0, men nogle fejl og begrænsninger er på todo -listen. Version 3.3 forbedres i detaljer. Version 3.5 understøtter OpenCL 2.2. Version 3.10 var med forbedringer og nye API'er. Annonceret på SC20 er ROCm 4.0 med understøttelse af AMD Compute Card Instinct MI 100. Faktisk dokumentation af 4.3.1 er tilgængelig på github. OpenCL 3.0 er i gang.

POCL

En bærbar implementering, der understøtter CPU'er og nogle GPU'er (via CUDA og HSA ). Bygger på Clang og LLVM . Med version 1.0 blev OpenCL 1.2 næsten fuldt implementeret sammen med nogle 2.x funktioner. Version 1.2 er med LLVM/CLANG 6.0, 7.0 og Full OpenCL 1.2 support med alle lukkede billetter i Milestone 1.2. OpenCL 2.0 er næsten fuldt implementeret. Version 1.3 Understøtter Mac OS X. Version 1.4 inkluderer understøttelse af LLVM 8.0 og 9.0. Version 1.5 implementerer LLVM/Clang 10 -understøttelse. Version 1.6 implementerer LLVM/Clang 11 -understøttelse og CUDA -acceleration. Faktiske mål er komplette OpenCL 2.x, OpenCL 3.0 og forbedring af ydeevnen. POCL 1.6 er med manuel optimering på samme niveau af Intel -computertid. Version 1.7 implementerer LLVM/Clang 12 -understøttelse og nogle nye OpenCL 3.0 -funktioner.

Shamrock

En Port of Mesa Clover til ARM med fuld understøttelse af OpenCL 1.2, ingen egentlig udvikling til 2.0.

FreeOCL

En CPU -fokuseret implementering af OpenCL 1.2, der implementerer en ekstern compiler for at skabe en mere pålidelig platform, ingen egentlig udvikling.

MOCL

En OpenCL-implementering baseret på POCL af NUDT-forskerne til Matrix-2000 blev frigivet i 2018. Matrix-2000-arkitekturen er designet til at erstatte Intel Xeon Phi-acceleratorer fra TianHe-2-supercomputeren. Denne programmeringsramme er bygget oven på LLVM v5.0 og genbruger også nogle kodestykker fra POCL. For at låse hardwarepotentialet op bruger enhedens runtime en push-baseret opgaveforsendelsesstrategi, og ydelsen af ​​kernelatomikken forbedres betydeligt. Denne ramme er blevet implementeret på TH-2A-systemet og er let tilgængelig for offentligheden. Noget af softwaren vil derefter blive overført til at forbedre POCL.

VC4CL

En OpenCL 1.2 -implementering til VideoCore IV (BCM2763) -processoren, der blev brugt i Raspberry Pi før dens model 4.

Leverandørimplementeringer

Tidslinje for leverandørimplementeringer

• Juni, 2008: Under Apples WWDC -konference blev en tidlig beta af Mac OS X Snow Leopard tilgængelig for deltagerne, den omfattede den første beta -implementering af OpenCL, cirka 6 måneder før den endelige version 1.0 -specifikation blev ratificeret i slutningen af ​​2008. De viste også to demoer. Den ene var et gitter med 8x8 skærme, der hver viste skærmen på en emuleret Apple II -maskine - i alt 64 uafhængige instanser, der hver kørte et berømt karatespil. Dette viste opgaveparallellisme på CPU'en. Den anden demo var en N-body-simulering, der kører på GPU'en på en Mac Pro, en dataparallel opgave.
• 10. december 2008: AMD og Nvidia holdt den første offentlige OpenCL-demonstration, en 75-minutters præsentation på SIGGRAPH Asia 2008. AMD viste en CPU-accelereret OpenCL-demo, der forklarede skalerbarheden af ​​OpenCL på en eller flere kerner, mens Nvidia viste en GPU-accelereret demo.
• 16. marts 2009: på den 4. Multicore Expo annoncerede Imagination Technologies PowerVR SGX543MP, dette virksomheds første GPU med OpenCL -understøttelse.
• 26. marts 2009: ved GDC 2009 demonstrerede AMD og Havok den første arbejdsimplementering til OpenCL -acceleration af Havok Cloth på AMD Radeon HD 4000 -serie GPU.
• 20. april 2009: Nvidia annoncerede frigivelsen af ​​sin OpenCL -driver og SDK til udviklere, der deltager i OpenCL Early Access -programmet.
• 5. august 2009: AMD afslørede de første udviklingsværktøjer til sin OpenCL -platform som en del af sit ATI Stream SDK v2.0 Beta Program.
• 28. august 2009: Apple udgav Mac OS X Snow Leopard , som indeholder en fuld implementering af OpenCL.
• 28. september 2009: Nvidia frigav sine egne OpenCL -drivere og SDK -implementering.
• 13. oktober 2009: AMD frigav den fjerde beta af ATI Stream SDK 2.0, som giver en komplet OpenCL -implementering på både R700 / R800 GPU'er og SSE3 -kompatible CPU'er. SDK'en er tilgængelig til både Linux og Windows.
• 26. november 2009: Nvidia frigav drivere til OpenCL 1.0 (rev 48).
• 27. oktober 2009: S3 udgav deres første produkt, der understøtter native OpenCL 1.0 - Chrome 5400E integreret grafikprocessor.
• 10. december 2009: VIA udgav deres første produkt, der understøtter OpenCL 1.0 - ChromotionHD 2.0 -videoprocessor inkluderet i VN1000 -chipset.
• 21. december 2009: AMD frigav produktionsversionen af ​​ATI Stream SDK 2.0, som giver OpenCL 1.0 -understøttelse af R800 GPU'er og beta -understøttelse for R700 GPU'er.
• 1. juni 2010: ZiiLABS offentliggjorde detaljer om deres første OpenCL -implementering for ZMS -processoren til håndholdte, integrerede og digitale hjemmeprodukter.
• 30. juni 2010: IBM udgav en fuldt ud kompatibel version af OpenCL 1.0.
• 13. september 2010: Intel offentliggjorde detaljer om deres første OpenCL -implementering til Sandy Bridge -chiparkitekturen. Sandy Bridge vil integrere Intels nyeste grafikkortteknologi direkte på den centrale processorenhed.
• 15. november 2010: Wolfram Research udgav Mathematica 8 med OpenCLLink -pakke.
• 3. marts 2011: Khronos Group annoncerer dannelsen af WebCL -arbejdsgruppen for at undersøge definitionen af ​​en JavaScript -binding til OpenCL. Dette skaber potentiale til at udnytte GPU og multi-core CPU parallel behandling fra en webbrowser .
• 31. marts 2011: IBM udgav en fuldt ud kompatibel version af OpenCL 1.1.
• 25. april 2011: IBM udgav OpenCL Common Runtime v0.1 til Linux på x86 Architecture.
• 4. maj 2011: Nokia Research frigiver en open source WebCL -udvidelse til Firefox -webbrowseren , der giver en JavaScript -binding til OpenCL.
• 1. juli 2011: Samsung Electronics frigiver en open source -prototypeimplementering af WebCL til WebKit, der leverer en JavaScript -binding til OpenCL.
• 8. august 2011: AMD frigav OpenCL-drevet AMD Accelerated Parallel Processing (APP) Software Development Kit (SDK) v2.5, som erstattede ATI Stream SDK som teknologi og koncept.
• 12. december 2011: AMD frigav AMD APP SDK v2.6, som indeholder et eksempel på OpenCL 1.2.
• 27. februar 2012: Portland Group frigav PGI OpenCL-kompilatoren til multi-core ARM- CPU'er.
• 17. april 2012: Khronos udgav et WebCL -arbejdsudkast.
• 6. maj 2013: Altera frigav Altera SDK til OpenCL, version 13.0. Det er i overensstemmelse med OpenCL 1.0.
• 18. november 2013: Khronos meddelte, at specifikationen for OpenCL 2.0 var blevet færdiggjort.
• 19. marts 2014: Khronos frigiver WebCL 1.0 -specifikationen
• 29. august 2014: Intel frigiver HD Graphics 5300 -driver, der understøtter OpenCL 2.0.
• 25. september 2014: AMD frigiver Catalyst 14.41 RC1, som inkluderer en OpenCL 2.0 -driver.
• 14. januar 2015: Xilinx Inc. annoncerer SDAccels udviklingsmiljø for OpenCL, C og C ++, opnår Khronos -overensstemmelse
• 13. april 2015: Nvidia frigiver WHQL -driver v350.12, som inkluderer OpenCL 1.2 -understøttelse af GPU'er baseret på Kepler eller senere arkitekturer. Driver 340+ understøtter OpenCL 1.1 til Tesla og Fermi.
• 26. august 2015: AMD frigav AMD APP SDK v3.0, som indeholder fuld understøttelse af OpenCL 2.0 og prøvekodning.
• 16. november 2015: Khronos meddelte, at specifikationen for OpenCL 2.1 var blevet færdiggjort.
• 18. april 2016: Khronos meddelte, at specifikationen til OpenCL 2.2 var foreløbigt færdiggjort.
• 3. november 2016 Intel -understøttelse af Gen7+ i OpenCL 2.1 i SDK 2016 r3
• 17. februar 2017: Nvidia begynder evalueringsunderstøttelse af OpenCL 2.0 med driver 378.66.
• 16. maj 2017: Khronos meddelte, at specifikationen for OpenCL 2.2 var blevet færdiggjort med SPIR-V 1.2.
• 14. maj 2018: Khronos annoncerede vedligeholdelsesopdatering til OpenCL 2.2 med Bugfix og forenede overskrifter.
• 27. april 2020: Khronos annoncerede foreløbig version af OpenCL 3.0
• 1. juni 2020: Intel Neo Runtime med OpenCL 3.0 til nye Tiger Lake
• 3. juni 2020: AMD annoncerede RocM 3.5 med OpenCL 2.2 Support
• 30. september 2020: Khronos meddelte, at specifikationerne for OpenCL 3.0 var blevet færdiggjort (CTS er også tilgængelig).
• 16. oktober 2020: Intel annoncerede med Neo 20.41 -understøttelse af OpenCL 3.0 (inkluderer hovedsageligt valgfri OpenCL 2.x)
• 6. april 2021: Nvidia understøtter OpenCL 3.0 til Ampere. Maxwell og senere GPU'er understøtter også OpenCL 3.0 med Nvidia -driver 465+.

Enheder

Som af 2016 OpenCL kører på Graphics behandlingsenheder , CPU'er med SIMD instruktioner, FPGA'er , Movidius Myriad 2 , Adapteva Helligtrekonger og DSPs .

Khronos Conformance Test Suite

For at være officielt i overensstemmelse skal en implementering bestå Khronos Conformance Test Suite (CTS), og resultaterne indsendes til Khronos Adopters Program. Khronos CTS -koden for alle OpenCL -versioner har været tilgængelig i open source siden 2017.

Overensstemmende produkter

Den Khronos Group fastholder en udvidet liste over OpenCL-kompatible produkter.

Alle standardkonforme implementeringer kan forespørges ved hjælp af et af clinfo-værktøjerne (der er flere værktøjer med samme navn og lignende funktionssæt).

Versionsunderstøttelse

Produkter og deres version af OpenCL -support inkluderer:

OpenCL 3.0 support

Al hardware med OpenCL 1.2+ er mulig, OpenCL 2.x kun valgfri, Khronos Test Suite tilgængelig siden 2020-10

• (2020) Intel NEO Compute: 20.41+ til Gen 12 Tiger Lake til Broadwell (inkluderer fuld 2.0 og 2.1 support og dele af 2.2)
• (2020) Intel 6., 7., 8., 9., 10., 11. generations processor ( Skylake , Kaby Lake , Coffee Lake , Comet Lake , Ice Lake , Tiger Lake ) med den nyeste Intel Windows -grafikdriver
• (2021) Intel 11., 12. generations processorer ( Rocket Lake , Alder Lake ) med den nyeste Intel Windows grafikdriver
• (2021) Nvidia Maxwell , Pascal , Volta , Turing og Ampere med Nvidia grafikdriver 465+

OpenCL 2.2 -understøttelse

Ingen endnu : Khronos Test Suite klar, med driveropdatering af al hardware med understøttelse af 2.0 og 2.1 mulig

• Intel NEO Compute: I gang med faktiske produkter
• ROCm: Version 3.5+ for det meste

OpenCL 2.1 support

• (2018+) Support backported til Intel 5. og 6. generations processorer ( Broadwell , Skylake )
• (2017+) Intel 7., 8., 9., 10. generation af processorer ( Kaby Lake , Coffee Lake , Comet Lake , Ice Lake )
• Khronos: med driver Opdater al hardware med 2.0 support mulig

OpenCL 2.0 support

• (2011+) AMD GCN GPU'er (HD 7700+/HD 8000/Rx 200/Rx 300/Rx 400/Rx 500/Rx 5000-serien), nogle GCN 1. generation kun 1.2 med nogle udvidelser
• (2013+) AMD GCN APU'er ( Jaguar , Steamroller , Puma , Gravemaskine & Zen -baseret)
• (2014+) Intel 5. og 6. generations processorer ( Broadwell , Skylake )
• (2015+) Qualcomm Adreno 5xx -serien
• (2018+) Qualcomm Adreno 6xx -serien
• (2017+) ARM Mali (Bifrost) G51 og G71 i Android 7.1 og Linux
• (2018+) ARM Mali (Bifrost) G31, G52, G72 og G76
• (2017+) ufuldstændig evalueringsstøtte: Nvidia Kepler , Maxwell , Pascal , Volta og Turing GPU'er (GeForce 600, 700, 800, 900 & 10-serier, Quadro K-, M- & P-serier, Tesla K-, M- & P-serien) med driverversion 378.66+

OpenCL 1.2 support

• (2011+) for nogle AMD GCN 1. generation nogle OpenCL 2.0 -funktioner ikke mulige i dag, men mange flere udvidelser end Terascale
• (2009+) AMD TeraScale 2 & 3 GPU'er (RV8xx, RV9xx i HD 5000-, 6000- og 7000 -serien)
• (2011+) AMD TeraScale APU'er ( K10 , Bobcat & Piledriver -baserede)
• (2012+) Nvidia Kepler, Maxwell, Pascal, Volta og Turing GPU'er (GeForce 600, 700, 800, 900, 10, 16, 20 serier, Quadro K-, M- & P-serier, Tesla K-, M- & P-serien)
• (2012+) Intel 3. og 4. generations processorer ( Ivy Bridge , Haswell )
• (2013+) Qualcomm Adreno 4xx -serien
• (2013+) ARM Mali Midgard 3. generation (T760)
• (2015+) ARM Mali Midgard 4. generation (T8xx)

OpenCL 1.1 support

• (2008+) nogle AMD TeraScale 1 GPU'er (RV7xx i HD4000-serien)
• (2008+) Nvidia Tesla, Fermi GPU'er (GeForce 8, 9, 100, 200, 300, 400, 500-serier, Quadro-serier eller Tesla-serier med Tesla eller Fermi GPU)
• (2011+) Qualcomm Adreno 3xx -serien
• (2012+) ARM Mali Midgard 1. og 2. generation (T-6xx, T720)

OpenCL 1.0 -understøttelse

• for det meste opdateret til 1.1 og 1.2 efter kun første driver til 1.0

Bærbarhed, ydeevne og alternativer

Et centralt træk ved OpenCL er portabilitet via sin abstrakte hukommelse og eksekveringsmodel , og programmøren er ikke i stand til direkte at bruge hardwarespecifikke teknologier såsom inline Parallel Thread Execution (PTX) til Nvidia GPU'er, medmindre de er villige til at opgive direkte portabilitet på andre platforme. Det er muligt at køre enhver OpenCL -kerne på en hvilken som helst konform implementering.

Kernens ydeevne er imidlertid ikke nødvendigvis bærbar på tværs af platforme. Eksisterende implementeringer har imidlertid vist sig at være konkurrencedygtige, når kernekoden er korrekt indstillet, og auto-tuning er blevet foreslået som en løsning på ydelsesportabilitetsproblemet, hvilket giver "acceptable ydelsesniveauer" i eksperimentelle lineære algebra-kerner. Portabilitet af en hel applikation indeholdende flere kerner med forskellig adfærd blev også undersøgt, og viser, at portabilitet kun krævede begrænsede afvejninger.

En undersøgelse ved Delft University fra 2011, der sammenlignede CUDA -programmer og deres enkle oversættelse til OpenCL C, fandt CUDA at overgå OpenCL med højst 30% om Nvidia -implementeringen. Forskerne bemærkede, at deres sammenligning kunne gøres mere retfærdig ved at anvende manuelle optimeringer til OpenCL -programmerne, i hvilket tilfælde der ikke var "nogen grund til, at OpenCL opnåede dårligere ydeevne end CUDA". Ydelsesforskellene kan for det meste tilskrives forskelle i programmeringsmodellen (især hukommelsesmodellen) og NVIDIAs kompilatoroptimeringer til CUDA sammenlignet med dem til OpenCL.

En anden undersøgelse fra D-Wave Systems Inc. fandt ud af, at "OpenCL-kernelens ydeevne er mellem ca. 13% og 63% langsommere, og ende-til-ende-tiden er mellem ca. 16% og 67% langsommere" end CUDAs ydeevne.

Det faktum, at OpenCL tillader, at arbejdsbyrder deles af CPU og GPU, der udfører de samme programmer, betyder, at programmører kan udnytte begge dele ved at dele arbejdet mellem enhederne. Dette fører til problemet med at beslutte, hvordan arbejdet skal opdeles, fordi de relative driftshastigheder er forskellige mellem enhederne. Maskinindlæring er blevet foreslået for at løse dette problem: Grewe og O'Boyle beskriver et system af supportvektormaskiner, der er uddannet i kompileringstidsfunktioner i et program, der kan afgøre enhedens opdelingsproblem statisk uden egentlig at køre programmerne for at måle deres ydeevne.

I en sammenligning af faktiske grafikkort i AMD RDNA 2 og Nvidia RTX Series er der et uafgjort resultat af OpenCL-Tests. Mulige ydelsesforøgelser ved brug af Nvidia CUDA eller OptiX blev ikke testet.

Se også

Referencer

eksterne links

• Officiel hjemmeside
• Officielt websted forWebCL
• International workshop om OpenCL ( IWOCL ) sponsoreret af The Khronos Group