OpenCL - OpenCL

OpenCL API

Původní autoři	Apple Inc.
Vývojáři	Skupina Khronos
První vydání	28. srpna 2009 ; Před 12 lety ( 2009-08-28 )
Stabilní uvolnění	3,0 / 30. září 2020 ; Před 12 měsíci ( 2020-09-30 )
Napsáno	C s vazbami C ++
Operační systém	Android (závisí na dodavateli), FreeBSD , Linux , macOS (přes Pocl), Windows
Plošina	ARMv7 , ARMv8 , Cell , IA-32 , POWER , x86-64
Typ	Heterogenní výpočetní API
Licence	Licence specifikace OpenCL
webová stránka	www .khronos .org /opencl /

OpenCL ( Open Computing Language ) je rámec pro psaní programů, které se provádějí napříč heterogenními platformami, skládající se z centrálních procesorových jednotek (CPU), grafických procesorových jednotek (GPU), procesorů digitálního signálu (DSP), polí programovatelných bran (FPGA) a dalších procesory nebo hardwarové akcelerátory . OpenCL specifikuje programovací jazyky (založené na C99 , C ++ 14 a C ++ 17 ) pro programování těchto zařízení a aplikačních programovacích rozhraní (API) pro ovládání platformy a spouštění programů na výpočetních zařízeních . OpenCL poskytuje standardní rozhraní pro paralelní výpočet pomocí paralelismu založeného na úkolech a datech .

OpenCL je otevřený standard udržovaný neziskovým technologickým konsorciem Khronos Group . Vyhovující implementace jsou k dispozici od společností Altera , AMD , ARM , Creative , IBM , Imagination , Intel , Nvidia , Qualcomm , Samsung , Vivante , Xilinx a ZiiLABS .

Přehled

OpenCL vidí počítačový systém jako sestávající z několika výpočetních zařízení , kterými mohou být centrální procesorové jednotky (CPU) nebo „akcelerátory“, jako jsou grafické procesorové jednotky (GPU), připojené k hostitelskému procesoru (CPU). Definuje jazyk podobný jazyku C pro psaní programů. Funkce prováděné na zařízení OpenCL se nazývají „ jádra “. Jedno výpočetní zařízení se obvykle skládá z několika výpočetních jednotek , které zase obsahují více prvků zpracování (PE). Jedno spuštění jádra může běžet na všech nebo mnoha PE souběžně. Jak je výpočetní zařízení rozděleno na výpočetní jednotky a PE, je na prodejci; o výpočetní jednotce lze uvažovat jako o „ jádru “, ale pojem jádro je těžké definovat ve všech typech zařízení podporovaných OpenCL (nebo dokonce v kategorii „CPU“) a počet výpočetních jednotek může být neodpovídají počtu jader nárokovaných v marketingové literatuře prodejců (což může být ve skutečnosti počítání pruhů SIMD ).

Kromě svého programovacího jazyka podobného C definuje OpenCL rozhraní pro programování aplikací (API), které umožňuje programům běžícím na hostiteli spouštět jádra na výpočetních zařízeních a spravovat paměť zařízení, která je (alespoň koncepčně) oddělená od paměti hostitele. Programy v jazyce OpenCL jsou určeny ke kompilaci za běhu , takže aplikace využívající OpenCL jsou přenosné mezi implementacemi pro různá hostitelská zařízení. Standard OpenCL definuje hostitelská rozhraní API pro C a C ++ ; API jiných výrobců existují pro jiné programovací jazyky a platformy, jako jsou Python , Java , Perl , D a .NET . Implementace standardu OpenCL se skládá z knihovny , který implementuje API pro C a C ++, a OpenCL C kompilátor pro výpočetní zařízení (S) je zaměřeno.

Aby bylo možné otevřít programovací model OpenCL jiným jazykům nebo ochránit zdroj jádra před inspekcí, lze jako cílový nezávislý způsob odesílání jader mezi front-end kompilátorem a OpenCL back použít standardní SPIR ( Standard Portable Intermediate Representation ). -konec.

Nedávno Khronos Group ratifikovala SYCL , programovací model vyšší úrovně pro OpenCL jako jednozdrojový DSEL založený na čistém C ++ 17 za účelem zlepšení produktivity programování . Kromě toho lze funkce C ++ použít také při implementaci zdrojů výpočetního jádra v jazyce C ++ pro jazyk OpenCL.

Hierarchie paměti

OpenCL definuje čtyřúrovňovou hierarchii paměti pro výpočetní zařízení:

• globální paměť: sdílí všechny prvky zpracování, ale má vysokou latenci přístupu ( __global );
• paměť jen pro čtení: menší, nízká latence, zapisovatelná hostitelským CPU, ale ne výpočetními zařízeními ( __constant );
• lokální paměť: sdílená skupinou prvků zpracování ( __local );
• soukromá paměť na prvek ( registry ; __private ).

Ne každé zařízení musí implementovat každou úroveň této hierarchie v hardwaru. Konzistence mezi různými úrovněmi v hierarchii je uvolněná a vynucovaná pouze explicitními synchronizačními konstrukcemi, zejména překážkami .

Zařízení mohou, ale nemusí sdílet paměť s hostitelským CPU. Hostitelské API poskytuje popisy vyrovnávacích pamětí zařízení a funkce pro přenos dat tam a zpět mezi hostitelem a zařízeními.

Jazyk jádra OpenCL

Programovací jazyk, který se používá k zápisu výpočetních jader, se nazývá jazyk jádra. OpenCL přijímá jazyky založené na C / C ++ k určení výpočtů jádra prováděných na zařízení s určitými omezeními a doplňky, které usnadňují efektivní mapování na heterogenní hardwarové prostředky akcelerátorů. K programování akcelerátorů ve standardu OpenCL byl tradičně používán OpenCL C, později byl vyvinut jazyk C ++ pro jádro OpenCL, který zdědil všechny funkce z OpenCL C, ale umožňoval používat funkce C ++ ve zdrojích jádra.

OpenCL C jazyk

OpenCL C je jazykový dialekt založený na C99 přizpůsobený modelu zařízení v OpenCL. Vyrovnávací paměti paměti se nacházejí na konkrétních úrovních hierarchie paměti a ukazatele jsou komentovány kvalifikátory oblastí __global , __local , __constant a __private , což odráží toto. Místo programu zařízení, který má hlavní funkci, jsou funkce OpenCL C označeny __kernel, aby signalizovaly, že jsou vstupními body do programu, který má být vyvolán z hostitelského programu. Ukazatele funkcí , bitová pole a pole s proměnnou délkou jsou vynechány a rekurze je zakázána. Standardní knihovna C je nahrazen vlastní sadu standardních funkcí, směřujících k programování matematický.

OpenCL C je rozšířen, aby usnadnil používání paralelismu s typy a operacemi vektorů, synchronizací a funkcemi pro práci s pracovními položkami a pracovními skupinami. Zejména kromě skalárních typů, jako jsou float a double , které se chovají podobně jako odpovídající typy v C, OpenCL poskytuje typy vektorů s pevnou délkou, jako je float4 (4-vektor floatů s jednoduchou přesností); takové vektorové typy jsou k dispozici v délkách dva, tři, čtyři, osm a šestnáct pro různé základní typy. Vectorizované operace na těchto typech jsou určeny k mapování na sady instrukcí SIMD , např. SSE nebo VMX , při spouštění programů OpenCL na CPU. Mezi další specializované typy patří typy obrázků 2-d a 3-d.

Příklad: násobení matice-vektoru

Každá invokace ( pracovní položka ) jádra vezme řádek zelené matice ( A v kódu), vynásobí tento řádek červeným vektorem ( x ) a umístí výsledek do zadání modrého vektoru ( y ). Počet sloupců n je předán jádru jako ncols ; počet řádků je implicitní v počtu pracovních položek vytvořených hostitelským programem.

Následuje algoritmus násobení matice a vektoru v 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;
}

Funkce jádra matvec počítá při každém vyvolání bodový součin jednoho řádku matice A a vektoru x :

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

Aby se to rozšířilo na plné násobení vektorů matice, runtime OpenCL mapuje jádro přes řádky matice. Na straně hostitele to dělá funkce clEnqueueNDRangeKernel ; bere jako argumenty jádro s provedením, její argumenty, a počet pracovních položkami, odpovídající počtu řádků v matici A .

Příklad: výpočet FFT

Tento příklad načte implementaci rychlé Fourierovy transformace (FFT) a spustí ji. Implementace je uvedena níže. Kód požádá knihovnu OpenCL o první dostupnou grafickou kartu, vytvoří paměťové vyrovnávací paměti pro čtení a zápis (z pohledu grafické karty), JIT zkompiluje jádro FFT a nakonec jádro asynchronně spustí. Výsledek transformace se v tomto příkladu nečte.

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

Skutečný výpočet v souboru „fft1D_1024_kernel_src.cl“ (na základě přizpůsobení FFT do architektury G80 ):

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

Úplnou implementaci OpenCL FFT s otevřeným zdrojovým kódem najdete na webových stránkách společnosti Apple.

C ++ pro jazyk OpenCL

V roce 2020 oznámil Khronos přechod na komunitní C ++ pro programovací jazyk OpenCL, který poskytuje funkce z C ++ 17 v kombinaci s tradičními funkcemi OpenCL C. Tento jazyk umožňuje využívat širokou škálu jazykových funkcí od standardního C ++ při zachování zpětné kompatibility s OpenCL C. Tím se vývojářům kódu jádra OpenCL otevírá bezproblémová cesta k funkcím C ++, protože mohou nadále používat známý tok programování a dokonce i nástroje jako také využít stávající rozšíření a knihovny dostupné pro OpenCL C.

Jazyková sémantika je popsána v dokumentaci publikované ve verzích úložiště OpenCL-Docs hostovaném skupinou Khronos, ale v současné době není skupinou Khronos ratifikována. Jazyk C ++ pro OpenCL není dokumentován v samostatném dokumentu a je založen na specifikaci C ++ a OpenCL C. Kompilátor Clang s otevřeným zdrojovým kódem podporuje C ++ pro OpenCL od vydání 9.

C ++ pro OpenCL byl původně vyvinut jako rozšíření kompilátoru Clang a objevil se ve verzi 9. Protože byl těsně spojený s OpenCL C a neobsahoval žádné specifické funkce Clang, byla jeho dokumentace znovu hostována v úložišti OpenCL-Docs z Khronos Group spolu se zdroji dalších specifikací a referenčních karet. První oficiální vydání tohoto dokumentu popisujícího C ++ pro OpenCL verze 1.0 bylo zveřejněno v prosinci 2020. C ++ pro OpenCL 1.0 obsahuje funkce z C ++ 17 a je zpětně kompatibilní s OpenCL C 2.0. Rozpracovaný návrh jeho dokumentace lze nalézt na webových stránkách Khronos.

Funkce

C ++ pro OpenCL podporuje většinu funkcí (syntakticky a sémanticky) z OpenCL C kromě vnořené rovnoběžnosti a bloků. Existují však drobné rozdíly v některých podporovaných funkcích, které se týkají především rozdílů v sémantice mezi C ++ a C. Například C ++ je přísnější na převody implicitních typů a nepodporuje kvalifikátor omezení typu. Následující funkce C ++ nejsou v C ++ pro OpenCL podporovány: virtuální funkce, operátor dynamic_cast, operátory new / delete bez umístění , výjimky, ukazatel na členské funkce, odkazy na funkce, standardní knihovny C ++. C ++ pro OpenCL rozšiřuje koncept oddělených paměťových oblastí ( adresních prostorů ) z funkcí OpenCL C na C ++ - funkční přetypování, šablony, členové třídy, reference, funkce lambda, operátory. Většina funkcí C ++ není k dispozici pro funkce jádra, např. Přetížení nebo šablony, libovolné rozložení tříd v typu parametru.

Příklad: aritmetika komplexních čísel

Následující fragment kódu ukazuje, jak lze implementovat jádra s aritmetikou komplexních čísel v jazyce C ++ pro jazyk OpenCL s pohodlným používáním funkcí C ++.

// 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

Prostředí pro nástroje a provádění

Jazyk C ++ pro OpenCL lze použít pro stejné aplikace nebo knihovny a stejným způsobem jako jazyk OpenCL C. Vzhledem k bohaté rozmanitosti funkcí jazyka C ++ mohou aplikace napsané v jazyce C ++ pro OpenCL vyjadřovat komplexní funkce pohodlněji než aplikace napsané v OpenCL C a zejména generické programovací paradigma z C ++ je pro vývojáře knihoven velmi atraktivní.

C ++ pro zdroje OpenCL lze kompilovat pomocí ovladačů OpenCL, které podporují rozšíření cl_ext_cxx_for_opencl . Arm oznámil podporu pro toto rozšíření v prosinci 2020. Vzhledem ke zvyšující se složitosti zrychlených algoritmů na zařízeních OpenCL se však očekává, že více aplikací bude kompilovat C ++ pro jádra OpenCL offline pomocí samostatných kompilátorů, jako je Clang, do spustitelného binárního formátu nebo přenosný binární formát např. SPIR-V. Takový spustitelný soubor lze načíst během provádění aplikací OpenCL pomocí vyhrazeného rozhraní OpenCL API.

Binární soubory kompilované ze zdrojů v C ++ pro OpenCL 1.0 lze spouštět na zařízeních kompatibilních s OpenCL 2.0. V závislosti na jazykových funkcích použitých v takových zdrojích jádra může být také spuštěn na zařízeních podporujících dřívější verze OpenCL nebo OpenCL 3.0.

Kromě ovladačů OpenCL lze jádra napsaná v jazyce C ++ pro OpenCL kompilovat pro provádění na zařízeních Vulkan pomocí kompilátoru clspv a běhové vrstvy clvk stejným způsobem jako jádra OpenCL C.

Příspěvky

C ++ pro OpenCL je otevřený jazyk vyvinutý komunitou přispěvatelů uvedených v jeho dokumentaci. Nové příspěvky k definici sémantiky jazyka nebo podpora nástrojů s otevřeným zdrojovým kódem jsou přijímány každým, koho to zajímá, jakmile jsou v souladu s hlavní filozofií designu a jsou zkontrolovány a schváleny zkušenými přispěvateli.

Dějiny

OpenCL byl původně vyvinut společností Apple Inc. , která je držitelem práv k ochranným známkám, a ve spolupráci s technickými týmy AMD , IBM , Qualcomm , Intel a Nvidia byl upřesněn na původní návrh . Apple předložil tento původní návrh skupině Khronos . 16. června 2008 byla vytvořena pracovní skupina Khronos Compute Working Group se zástupci společností CPU, GPU, embedded-processor a software. Tato skupina pracovala pět měsíců na dokončení technických podrobností specifikace pro OpenCL 1.0 do 18. listopadu 2008. Tato technická specifikace byla přezkoumána členy Khronos a schválena pro veřejné vydání 8. prosince 2008.

OpenCL 1.0

OpenCL 1.0 vydán s Mac OS X Snow Leopard 28. srpna 2009. Podle tiskové zprávy společnosti Apple:

Snow Leopard dále rozšiřuje podporu moderního hardwaru pomocí OpenCL (Open Computing Language), který umožňuje jakékoli aplikaci využít obrovské gigaflopy výpočetního výkonu GPU, které byly dříve k dispozici pouze pro grafické aplikace. OpenCL je založen na programovacím jazyce C a byl navržen jako otevřený standard.

AMD se rozhodlo podporovat OpenCL namísto nyní zastaralého Close to Metal v jeho rámci Stream . RapidMind oznámil přijetí OpenCL pod svou vývojovou platformu pro podporu GPU od více prodejců s jedním rozhraním. 9. prosince 2008 Nvidia oznámila svůj záměr přidat do své sady GPU Computing Toolkit plnou podporu specifikace OpenCL 1.0. 30. října 2009 vydala IBM svou první implementaci OpenCL jako součást kompilátorů XL .

Zrychlení výpočtů s faktorem na 1000 je možné s OpenCL v grafických kartách oproti běžnému CPU. Některé důležité funkce příští verze OpenCL jsou v 1.0 volitelné, jako jsou operace s dvojitou přesností nebo poloviční přesností.

OpenCL 1.1

OpenCL 1.1 byl ratifikován skupinou Khronos 14. června 2010 a přidává významné funkce pro zvýšenou flexibilitu paralelního programování, funkčnost a výkon, včetně:

• Nové datové typy včetně třísložkových vektorů a dalších obrazových formátů;
• Zpracování příkazů z více podprocesů hostitele a zpracování vyrovnávacích pamětí na více zařízeních;
• Operace v oblastech vyrovnávací paměti včetně čtení, zápisu a kopírování 1D, 2D nebo 3D obdélníkových oblastí;
• Vylepšené používání událostí k řízení a řízení provádění příkazů;
• Další vestavěné funkce C OpenCL, jako je celočíselná svorka, náhodné přehrávání a asynchronní postupné kopie;
• Vylepšená interoperabilita OpenGL díky efektivnímu sdílení obrázků a vyrovnávacích pamětí propojením událostí OpenCL a OpenGL.

OpenCL 1.2

15. listopadu 2011 skupina Khronos oznámila specifikaci OpenCL 1.2, která oproti předchozím verzím přidala významné funkce, pokud jde o výkon a funkce pro paralelní programování. Mezi nejvýznamnější funkce patří:

• Rozdělení zařízení: schopnost rozdělit zařízení na dílčí zařízení tak, aby bylo možné přiřazení práce přiřazovat jednotlivým výpočetním jednotkám. To je užitečné pro rezervaci oblastí zařízení, aby se snížila latence časově kritických úkolů.
• Samostatná kompilace a propojení objektů: funkce pro kompilaci OpenCL do externích knihoven pro zahrnutí do jiných programů.
• Vylepšená podpora obrazu (volitelně): 1.2 přidává podporu pro 1D obrázky a 1D/2D obrazová pole. Rozšíření pro sdílení OpenGL nyní nově umožňují použít k vytváření obrázků OpenCL textury OpenGL 1D a pole textur 1D/2D.
• Vestavěná jádra: vlastní zařízení, která obsahují specifické jedinečné funkce, jsou nyní integrována blíže do rámce OpenCL. Jádra lze volat pro použití specializovaných nebo neprogramovatelných aspektů základního hardwaru. Mezi příklady patří kódování/dekódování videa a procesory digitálního signálu.
• Funkce DirectX: Sdílení povrchů médií DX9 umožňuje efektivní sdílení mezi povrchy médií OpenCL a DX9 nebo DXVA . Stejně tak je u DX11 povoleno bezproblémové sdílení mezi povrchy OpenCL a DX11.
• Možnost vynutit kompatibilitu IEEE 754 pro matematiku s jednoduchou přesností s plovoucí desetinnou čárkou: OpenCL ve výchozím nastavení umožňuje, aby jednotlivé přesné operace dělení, reciproční a odmocniny byly méně přesné než správně zaokrouhlené hodnoty, které IEEE 754 vyžaduje. Pokud programátor předá kompilátoru argument příkazového řádku „-cl-fp32-korektně-zaokrouhlený-rozdělený-sqrt“, budou tyto tři operace vypočítány podle požadavků IEEE 754, pokud to implementace OpenCL implementuje, a nepodaří se je zkompilovat, pokud Implementace OpenCL nepodporuje výpočet těchto operací na jejich správně zaokrouhlené hodnoty definované ve specifikaci IEEE 754. Tato schopnost je doplněna schopností dotazovat se na implementaci OpenCL a určit, zda může provádět tyto operace s přesností IEEE 754.

OpenCL 2.0

18. listopadu 2013 skupina Khronos oznámila ratifikaci a veřejné vydání finalizované specifikace OpenCL 2.0. Aktualizace a doplňky OpenCL 2.0 zahrnují:

• Sdílená virtuální paměť
• Vnořený paralelismus
• Obecný adresní prostor
• Obrázky (volitelné, včetně 3D obrázku)
• Atomy C11
• Potrubí
• Rozšíření klientského ovladače instalovatelné pro Android
• prodloužena poloviční přesnost s volitelným rozšířením cl_khr_fp16
• cl_double: dvojitá přesnost IEEE 754 (volitelně)

OpenCL 2.1

Ratifikace a vydání prozatímní specifikace OpenCL 2.1 byla oznámena 3. března 2015 na Game Developer Conference v San Francisku. Byl vydán 16. listopadu 2015. Představil jazyk jádra OpenCL C ++, založený na podmnožině C ++ 14 , při zachování podpory již existujícího jazyka jádra OpenCL C. Vulkan a OpenCL 2.1 sdílejí SPIR-V jako prostřední reprezentaci, která umožňuje front-endům jazyka na vysoké úrovni sdílet společný cíl kompilace. Mezi aktualizace rozhraní API OpenCL patří:

• Další funkce podskupiny
• Kopírování objektů a stavů jádra
• Dotazy časovače zařízení s nízkou latencí
• Požití kódu SPIR-V za běhu
• Pokyny pro prioritu spuštění pro fronty
• Zásilky nulové velikosti od hostitele

AMD, ARM , Intel, HPC a YetiWare deklarovaly podporu pro OpenCL 2.1.

OpenCL 2.2

OpenCL 2.2 přináší jádrový jazyk OpenCL C ++ do základní specifikace pro výrazně zvýšenou produktivitu paralelního programování. Byla vydána 16. května 2017. Aktualizace údržby vydaná v květnu 2018 s opravami chyb.

• Jazyk jádra OpenCL C ++ je statickou podmnožinou standardu C ++ 14 a zahrnuje třídy, šablony, výrazy lambda, přetížení funkcí a mnoho dalších konstrukcí pro generické a metaprogramování.
• Používá nový přechodný jazyk Khronos SPIR-V 1.1, který plně podporuje jazyk jádra OpenCL C ++.
• Funkce knihovny OpenCL nyní mohou používat jazyk C ++ k zajištění zvýšené bezpečnosti a snížení nedefinovaného chování při přístupu k funkcím, jako jsou atomika, iterátory, obrázky, vzorkovače, potrubí a vestavěné typy a adresní prostory ve frontě zařízení.
• Pipe storage je nový typ na straně zařízení v OpenCL 2.2, který je užitečný pro implementace FPGA tím, že v době kompilace je známa velikost a typ konektivity, což umožňuje efektivní komunikaci v rozsahu zařízení mezi jádry.
• OpenCL 2.2 také obsahuje funkce pro vylepšenou optimalizaci generovaného kódu: aplikace mohou poskytovat hodnotu konstanty specializace v době kompilace SPIR-V, nový dotaz dokáže detekovat netriviální konstruktory a destruktory globálních objektů rozsahu programu a lze nastavit zpětná volání uživatelů v době vydání programu.
• Běží na jakémkoli hardwaru podporujícím OpenCL 2.0 (je vyžadována pouze aktualizace ovladače).

OpenCL 3.0

Specifikace OpenCL 3.0 byla vydána 30. září 2020 poté, co byla v náhledu od dubna 2020. Funkce OpenCL 1.2 se stala povinným základem, zatímco všechny funkce OpenCL 2.xa OpenCL 3.0 byly volitelně. Specifikace zachovává jazyk OpenCL C a zastarává jazyk jádra OpenCL C ++ a nahrazuje jej jazykem C ++ pro jazyk OpenCL na základě kompilátoru Clang / LLVM, který implementuje podmnožinu C ++ 17 a SPIR-V přechodný kód. Verze 3.0.7 C ++ pro OpenCL s některými rozšířeními Khronos openCL byla představena na IWOCL 21.

Plán

Mezinárodní seminář o OpenCL (IWOCL) v držení Khronos Group

Při vydání OpenCL 2.2 skupina Khronos oznámila, že OpenCL se bude pokud možno sbližovat s Vulkanem , což umožní flexibilitu nasazení softwaru OpenCL přes obě API. To nyní prokázal Adobe Premiere Rush pomocí kompilátoru open source clspv ke kompilaci významného množství kódu jádra OpenCL C pro spuštění v běhu Vulkan pro nasazení v systému Android. OpenCL má výhledovou mapu nezávislou na Vulkanu, přičemž „OpenCL Next“ je ve vývoji a cílené vydání v roce 2020. OpenCL Next může integrovat rozšíření jako Vulkan / OpenCL Interop, Scratch-Pad Memory Management, Extended Subgroups, SPIR-V 1.4 ingestion a Informace o rozšířeném ladění SPIR-V. OpenCL také zvažuje zavaděč a vrstvy podobné Vulkan a „flexibilní profil“ pro flexibilitu nasazení na více typech akcelerátorů.

Implementace open source

clinfo, nástroj příkazového řádku pro zobrazení informací OpenCL

OpenCL se skládá ze sady záhlaví a sdíleného objektu, který je načten za běhu. Instalovatelný klientský ovladač (ICD) musí být nainstalován na platformě pro každou třídu dodavatele, pro kterou by běhový modul potřeboval podporovat. To znamená, že například za účelem podpory zařízení Nvidia na platformě Linux by bylo nutné nainstalovat Nvidia ICD tak, aby běhový modul OpenCL (zavaděč ICD) dokázal najít ICD pro dodavatele a vhodně přesměrovat hovory . Standardní hlavička OpenCL je používána spotřebitelskou aplikací; volání každé funkce je pak proxy modulem runtime OpenCL příslušnému ovladači pomocí ICD. Každý dodavatel musí implementovat každé volání OpenCL do svého ovladače.

Implementace OpenCL pro Apple, Nvidia, RapidMind a Gallium3D jsou založeny na technologii LLVM Compiler a používají jako frontend kompilátor Clang .

MESA Gallium Compute

Implementace OpenCL (skutečná verze 1.1 nekompletní, většinou hotová AMD Radeon GCN ) pro řadu platforem je udržována jako součást projektu Gallium Compute Project, který staví na práci projektu Mesa na podpoře více platforem. Dříve se tomu říkalo CLOVER., Skutečný vývoj: většinou podpora spouštění neúplného frameworku se skutečnými LLVM a CLANG, některé nové funkce jako fp16 v 17.3, Target Complete OpenCL 1.0, 1.1 a 1.2 pro AMD a Nvidia. Nový základní vývoj provádí Red Hat se SPIR-V také pro Clover. New Target je modulární OpenCL 3.0 s plnou podporou OpenCL 1.2. Aktuální stav je k dispozici v Mesamatrixu. Obrazové podpory jsou zde v centru pozornosti vývoje.

BÉŽOVÁ

Implementace Intel pro své Ivy Bridge + hardware byl propuštěn v roce 2013. Tento software z Číny tým Intelu, přitahoval kritiku od vývojářů společnosti AMD a Red Hat , stejně jako Michael Larabel ze Phoronix . Aktuální verze 1.3.2 podporuje OpenCL 1.2 Complete (Ivy Bridge a vyšší) a OpenCL 2.0 volitelně pro Skylake a novější. do systému Beignet byla přidána podpora pro Android.

NEO

Implementace od Intelu pro hardware Gen. 8 Broadwell + Gen. 9 vydaná v roce 2018. Tento ovladač nahrazuje implementaci Beignet pro podporované platformy (ne starší 6. gen pro Haswell). NEO poskytuje podporu OpenCL 2.1 na platformách Core a OpenCL 1.2 na platformách Atom. Ve skutečnosti jsou v roce 2020 podporovány také Graphic Gen 11 Ice Lake a Gen 12 Tiger Lake. Nový OpenCL 3.0 je k dispozici pro Alder Lake, Tiger Lake až Broadwell s verzí 20.41+. Obsahuje nyní volitelný OpenCL 2.0, 2.1 Kompletní funkce a některé z 2.2.

ROCm

ROCm (Radeon Open Compute), vytvořený jako součást AMD GPUOpen , je open source projekt Linux postavený na OpenCL 1.2 s jazykovou podporou 2.0. Systém je kompatibilní se všemi moderními procesory AMD a APU (částečně GFX 7, GFX 8 a 9), stejně jako s procesory Intel Gen7.5+ (pouze s PCI 3.0). S verzí 1.9 je podpora v některých bodech rozšířena experimentálně na Hardware s PCIe 2.0 a bez atomiky. Přehled skutečné práce se provádí na XDC2018. ROCm verze 2.0 podporuje Full OpenCL 2.0, ale některé chyby a omezení jsou na seznamu úkolů. Verze 3.3 se v detailech zlepšuje. Verze 3.5 podporuje OpenCL 2.2. Verze 3.10 byla s vylepšeními a novými API. Oznámeno na SC20 je ROCm 4.0 s podporou AMD Compute Card Instinct MI 100. Aktuální dokumentace 4.3.1 je k dispozici na github. OpenCL 3.0 probíhá.

POCL

Přenosná implementace podporující CPU a některé GPU (přes CUDA a HSA ). Navazující na Clang a LLVM . Ve verzi 1.0 byl OpenCL 1.2 téměř plně implementován spolu s některými funkcemi 2.x. Verze 1.2 je s podporou LLVM/CLANG 6.0, 7.0 a Full OpenCL 1.2 se všemi uzavřenými tikety v Milestone 1.2. OpenCL 2.0 je téměř plně implementován. Verze 1.3 Podporuje Mac OS X. Verze 1.4 obsahuje podporu pro LLVM 8.0 a 9.0. Verze 1.5 implementuje podporu LLVM/Clang 10. Verze 1.6 implementuje podporu LLVM/Clang 11 a CUDA Acceleration. Skutečnými cíli jsou kompletní OpenCL 2.x, OpenCL 3.0 a zlepšení výkonu. POCL 1.6 je s manuální optimalizací na stejné úrovni výpočetního běhu Intel. Verze 1.7 implementuje podporu LLVM/Clang 12 a některé nové funkce OpenCL 3.0.

Trojlístek

Port of Mesa Clover pro ARM s plnou podporou OpenCL 1.2, žádný skutečný vývoj pro 2.0.

FreeOCL

Implementace OpenCL 1.2 zaměřená na CPU, která implementuje externí kompilátor pro vytvoření spolehlivější platformy, žádný skutečný vývoj.

MOCL

Implementace OpenCL založená na POCL výzkumníky NUDT pro Matrix-2000 byla vydána v roce 2018. Architektura Matrix-2000 je navržena tak, aby nahradila akcelerátory Intel Xeon Phi superpočítače TianHe-2. Tento programovací rámec je postaven na LLVM v5.0 a znovu používá také některé části kódu z POCL. K odblokování hardwarového potenciálu využívá modul runtime zařízení strategii dispečinku úloh založenou na push a výrazně se zlepšuje výkon atomové jádra. Tento rámec byl nasazen v systému TH-2A a je snadno dostupný veřejnosti. Část softwaru bude dále přenesena za účelem vylepšení POCL.

VC4CL

Implementace OpenCL 1.2 pro procesor VideoCore IV (BCM2763) používaný v Raspberry Pi před jeho modelem 4.

Implementace dodavatele

Časová osa implementací dodavatele

• Červen 2008: Během konference WWDC společnosti Apple byla účastníkům zpřístupněna raná beta systému Mac OS X Snow Leopard , která zahrnovala první beta implementaci OpenCL, přibližně 6 měsíců před ratifikací finální verze verze 1.0 koncem roku 2008. Ukázaly také dvě ukázky. Jedna byla vykreslena mřížkou 8x8 obrazovek, z nichž každá zobrazovala obrazovku emulovaného stroje Apple II - celkem 64 nezávislých instancí, z nichž každá provozovala slavnou hru karate. To ukázalo paralelnost úkolů na CPU. Druhou ukázkou byla simulace těla N běžící na GPU Macu Pro, datový paralelní úkol.
• 10. prosince 2008: AMD a Nvidia uspořádaly první veřejnou demonstraci OpenCL, 75minutovou prezentaci na SIGGRAPH Asia 2008. AMD ukázala ukázku OpenCL s akcelerací CPU, která vysvětluje škálovatelnost OpenCL na jednom nebo více jádrech, zatímco Nvidia ukázala akceleraci GPU demo.
• 16. března 2009: Na 4. Multicore Expo představila společnost Imagination Technologies PowerVR SGX543MP, první GPU této společnosti s podporou OpenCL.
• 26. března 2009: Na veletrhu GDC 2009 AMD a Havok předvedly první funkční implementaci akceleračního oblečení Havok Cloth s podporou OpenCL na GPU řady AMD Radeon HD 4000 .
• 20. dubna 2009: Nvidia oznámila vydání svého ovladače OpenCL a SDK vývojářům, kteří se účastní jeho programu předběžného přístupu OpenCL.
• 5. srpna 2009: AMD představilo první vývojové nástroje pro svou platformu OpenCL jako součást svého programu ATI Stream SDK v2.0 Beta.
• 28. srpna 2009: Apple vydal Mac OS X Snow Leopard , který obsahuje plnou implementaci OpenCL.
• 28. září 2009: Nvidia vydala vlastní ovladače OpenCL a implementaci SDK.
• 13. října 2009: AMD vydala čtvrtou beta verzi ATI Stream SDK 2.0, která poskytuje kompletní implementaci OpenCL na GPU R700 / R800 i na procesorech s podporou SSE3 . Sada SDK je k dispozici pro Linux i Windows.
• 26. listopadu 2009: Nvidia vydala ovladače pro OpenCL 1.0 (rev. 48).
• 27. října 2009: S3 vydal svůj první produkt podporující nativní OpenCL 1.0 - grafický procesor Chrome 5400E.
• 10.12.2009 : VIA vydala svůj první produkt podporující video procesor OpenCL 1.0 - ChromotionHD 2.0 obsažený v čipové sadě VN1000.
• 21. prosince 2009: AMD vydala produkční verzi ATI Stream SDK 2.0, která poskytuje podporu OpenCL 1.0 pro GPU R800 a beta podporu pro R700 GPU.
• 1. června 2010: ZiiLABS zveřejnil podrobnosti o své první implementaci OpenCL pro procesor ZMS pro ruční, vestavěné a digitální domácí produkty.
• 30. června 2010: IBM vydala plně kompatibilní verzi OpenCL 1.0.
• 13. září 2010: Intel zveřejnil podrobnosti o své první implementaci OpenCL pro čipovou architekturu Sandy Bridge. Sandy Bridge bude integrovat nejnovější technologii grafických čipů Intel přímo do centrální procesorové jednotky.
• 15. listopadu 2010: Společnost Wolfram Research vydala Mathematica 8 s balíčkem OpenCLLink .
• 3. března 2011: Skupina Khronos oznamuje vytvoření pracovní skupiny WebCL, která bude zkoumat definování vazby JavaScriptu na OpenCL. To vytváří potenciál pro využití paralelního zpracování GPU a vícejádrových procesorů z webového prohlížeče .
• 31. března 2011: IBM vydala plně kompatibilní verzi OpenCL 1.1.
• 25. dubna 2011: IBM vydala OpenCL Common Runtime v0.1 pro Linux na architektuře x86.
• 4. května 2011: Nokia Research vydává open source rozšíření WebCL pro webový prohlížeč Firefox , které poskytuje vazbu OpenCL pro JavaScript.
• 1. července 2011: Samsung Electronics vydává open source prototypovou implementaci WebCL pro WebKit, která poskytuje vazbu OpenCL na JavaScript.
• 08.08.2011: AMD vydala OpenCL-řízený AMD Accelerated Parallel Processing (APP) Software Development Kit (SDK) v2.5, nahrazující ATI Stream SDK jako technologii a koncept.
• 12. prosince 2011: AMD vydala AMD APP SDK v2.6, která obsahuje náhled OpenCL 1.2.
• 27. února 2012: Skupina Portland vydala kompilátor PGI OpenCL pro vícejádrové procesory ARM .
• 17. dubna 2012: Khronos vydal pracovní koncept WebCL.
• 06.05.2013: Altera vydala Altera SDK pro OpenCL, verze 13.0. Je v souladu s OpenCL 1.0.
• 18. listopadu 2013: Khronos oznámil, že specifikace pro OpenCL 2.0 byla dokončena.
• 19. března 2014: Khronos vydává specifikaci WebCL 1.0
• 29. srpna 2014: Intel vydává ovladač HD Graphics 5300, který podporuje OpenCL 2.0.
• 25. září 2014: AMD uvádí Catalyst 14.41 RC1, který obsahuje ovladač OpenCL 2.0.
• 14. ledna 2015: Xilinx Inc. oznamuje vývojové prostředí SDAccel pro OpenCL, C a C ++, dosahuje shody Khronos
• 13. dubna 2015: Nvidia vydává ovladač WHQL v350.12, který obsahuje podporu OpenCL 1.2 pro GPU založené na architektuře Kepler nebo novějších. Ovladač 340+ podporuje OpenCL 1.1 pro Tesla a Fermi.
• 26. srpna 2015: AMD vydala AMD APP SDK v3.0, která obsahuje plnou podporu OpenCL 2.0 a ukázkové kódování.
• 16. listopadu 2015: Khronos oznámil, že specifikace pro OpenCL 2.1 byla dokončena.
• 18. dubna 2016: Khronos oznámil, že specifikace pro OpenCL 2.2 byla prozatímně dokončena.
• 3. listopadu 2016 Podpora Intel pro Gen7+ OpenCL 2.1 v SDK 2016 r3
• 17. února 2017: Nvidia začíná s podporou hodnocení OpenCL 2.0 s ovladačem 378,66.
• 16. května 2017: Khronos oznámil, že specifikace pro OpenCL 2.2 byla dokončena pomocí SPIR-V 1.2.
• 14. května 2018: Khronos oznámil aktualizaci údržby pro OpenCL 2.2 s opravou chyb a sjednocenými hlavičkami.
• 27. dubna 2020: Khronos oznámil prozatímní verzi OpenCL 3.0
• 1. června 2020: Intel Neo Runtime s OpenCL 3.0 pro nové Tiger Lake
• 3. června 2020: AMD oznámila RocM 3.5 s podporou OpenCL 2.2
• 30. září 2020: Khronos oznámil, že byly dokončeny specifikace pro OpenCL 3.0 (k dispozici je také CTS).
• 16. října 2020: Intel oznámil podporu Neo 20.41 pro OpenCL 3.0 (zahrnuje většinou volitelný OpenCL 2.x)
• 6. dubna 2021: Nvidia podporuje OpenCL 3.0 pro Ampere. GPU Maxwell a novější také podporují OpenCL 3.0 s ovladačem Nvidia 465+.

Zařízení

Od roku 2016 běží OpenCL na grafických procesorových jednotkách , CPU s instrukcemi SIMD , FPGA , Movidius Myriad 2 , Adapteva epiphany a DSP .

Testovací sada shody Khronos

Aby byla implementace oficiálně v souladu, musí projít testovací sadou Khronos Conformance Test Suite (CTS), přičemž výsledky budou odeslány do programu pro osvojitele Khronos. Kód Khronos CTS pro všechny verze OpenCL je v open source k dispozici od roku 2017.

Shodné výrobky

Khronos Group udržuje rozšířený seznam OpenCL-konformní produkty.

Všechny standardně konformní implementace lze dotazovat pomocí jednoho z nástrojů klinfo (existuje více nástrojů se stejným názvem a podobnou sadou funkcí).

Podpora verzí

Produkty a jejich verze podpory OpenCL zahrnují:

Podpora OpenCL 3.0

Je možný veškerý hardware s OpenCL 1.2+, OpenCL 2.x pouze volitelný, Khronos Test Suite je k dispozici od 2020-10

• (2020) Intel NEO Compute: 20,41+ pro Gen 12 Tiger Lake to Broadwell (zahrnuje plnou podporu 2.0 a 2.1 a části 2.2)
• (2020) Procesory Intel 6., 7., 8., 9., 10., 11. generace ( Skylake , Kaby Lake , Coffee Lake , Comet Lake , Ice Lake , Tiger Lake ) s nejnovějším grafickým ovladačem Intel Windows
• (2021) Procesory Intel 11., 12. generace ( Rocket Lake , Alder Lake ) s nejnovějším grafickým ovladačem Intel Windows
• (2021) Nvidia Maxwell , Pascal , Volta , Turing a Ampere s grafickým ovladačem Nvidia 465+

Podpora OpenCL 2.2

Zatím žádný : Khronos Test Suite připraven, s aktualizací ovladače veškerý hardware s podporou 2.0 a 2.1

• Intel NEO Compute: Probíhá zpracování skutečných produktů
• ROCm: Verze 3.5+ většinou

Podpora OpenCL 2.1

• (2018+) Podpora zpětněportována na procesory Intel 5. a 6. generace ( Broadwell , Skylake )
• (2017+) procesory Intel 7th, 8th, 9th, 10th gen ( Kaby Lake , Coffee Lake , Comet Lake , Ice Lake )
• Khronos: s aktualizací ovladače je možný veškerý hardware s podporou 2.0

Podpora OpenCL 2.0

• (2011+) AMD GCN GPU (HD 7700+/HD 8000/Rx 200/Rx 300/Rx 400/Rx 500/Rx 5000-Series), některé GCN 1. generace pouze 1.2 s některými rozšířeními
• (2013+) AMD GCN APU's ( Jaguar , Steamroller , Puma , Excavator & Zen -based)
• (2014+) procesory Intel 5. a 6. generace ( Broadwell , Skylake )
• (2015+) Řada Qualcomm Adreno 5xx
• (2018+) Řada Qualcomm Adreno 6xx
• (2017+) ARM Mali (Bifrost) G51 a G71 v systému Android 7.1 a Linux
• (2018+) ARM Mali (Bifrost) G31, G52, G72 a G76
• (2017+) neúplná podpora hodnocení: Nvidia Kepler , Maxwell , Pascal , Volta a Turing GPU (řady GeForce 600, 700, 800, 900 a 10, řady Quadro K-, M- & P, Tesla K-, M- & P-series) s verzí ovladače 378.66+

Podpora OpenCL 1.2

• (2011+) pro některé AMD GCN 1. generace některé funkce OpenCL 2.0 dnes nejsou možné, ale mnohem více rozšíření než Terascale
• (2009+) AMD TeraScale 2 & 3 GPU (RV8xx, RV9xx in HD řady 5000, 6000 a 7000)
• (2011+) AMD TeraScale APU (na bázi K10 , Bobcat a Piledriver )
• (2012+) GPU Nvidia Kepler, Maxwell, Pascal, Volta a Turing (řady GeForce 600, 700, 800, 900, 10, 16, 20, Quadro K-, M- & P, Tesla K-, M- & Řada P)
• (2012+) Procesory Intel 3. a 4. generace ( Ivy Bridge , Haswell )
• (2013+) Řada Qualcomm Adreno 4xx
• (2013+) ARM Mali Midgard 3. gen (T760)
• (2015+) ARM Mali Midgard 4th gen (T8xx)

Podpora OpenCL 1.1

• (2008+) některé grafické karty AMD TeraScale 1 (RV7xx v řadě HD4000)
• (2008+) Nvidia Tesla, Fermi GPU (GeForce 8, 9, 100, 200, 300, 400, 500-series, Quadro-series or Tesla-series with Tesla or Fermi GPU)
• (2011+) Řada Qualcomm Adreno 3xx
• (2012+) ARM Mali Midgard 1. a 2. generace (T-6xx, T720)

Podpora OpenCL 1.0

• většinou aktualizovány na 1.1 a 1.2 po prvním ovladači pouze pro 1.0

Přenosnost, výkon a alternativy

Klíčovou vlastností OpenCL je přenositelnost prostřednictvím abstrahovaného modelu paměti a provedení a programátor není schopen přímo používat technologie specifické pro hardware, jako je inline Parallel Thread Execution (PTX) pro GPU Nvidia, pokud nejsou ochotni vzdát se přímé přenositelnosti na jiných platformách. Je možné spustit jakékoli jádro OpenCL na jakékoli kompatibilní implementaci.

Výkon jádra však nemusí být nutně přenositelný napříč platformami. Ukázalo se však, že stávající implementace jsou konkurenceschopné, když je kód jádra správně vyladěn, a jako řešení problému s přenositelností výkonu bylo navrženo automatické ladění, které v experimentálních jádrech lineární algebry poskytuje „přijatelné úrovně výkonu“. Byla také studována přenositelnost celé aplikace obsahující více jader s různým chováním a ukazuje, že přenositelnost vyžadovala pouze omezené kompromisy.

Studie na univerzitě Delft z roku 2011, která srovnávala programy CUDA a jejich přímý překlad do OpenCL C, zjistila, že CUDA překonává OpenCL nejvýše o 30% při implementaci Nvidia. Vědci poznamenali, že jejich srovnání by mohlo být spravedlivější použitím manuálních optimalizací na programy OpenCL, v takovém případě „nebyl žádný důvod, aby OpenCL dosahoval horšího výkonu než CUDA“. Rozdíly ve výkonu lze většinou přičíst rozdílům v programovacím modelu (zejména v paměťovém modelu) a optimalizacím kompilátoru NVIDIA pro CUDA ve srovnání s optimalizací pro OpenCL.

Další studie společnosti D-Wave Systems Inc. zjistila, že „Výkon jádra OpenCL je o přibližně 13% až 63% pomalejší a doba mezi koncovými body je o přibližně 16% až 67% pomalejší“ než výkon CUDA.

Skutečnost, že OpenCL umožňuje sdílení pracovních zátěží CPU a GPU při provádění stejných programů, znamená, že programátoři mohou využívat obojí dělením práce mezi zařízeními. To vede k problému při rozhodování o rozdělení práce, protože relativní rychlosti operací se mezi zařízeními liší. K vyřešení tohoto problému bylo navrženo strojové učení : Grewe a O'Boyle popisují systém strojů podpůrných vektorů vyškolených na funkcích programu při kompilaci, které dokážou staticky rozhodnout o problému s rozdělováním zařízení, aniž by ve skutečnosti spustily programy pro měření jejich výkonu.

Při srovnání skutečných grafických karet řady AMD RDNA 2 a Nvidia RTX existuje nerozhodný výsledek testů OpenCL. Možné zvýšení výkonu při použití Nvidia CUDA nebo OptiX nebylo testováno.

Viz také

Reference

externí odkazy

• Oficiální webové stránky
• Oficiální web proWebCL
• Mezinárodní workshop o OpenCL ( IWOCL ) sponzorovaný skupinou The Khronos Group