OpenCL

aus Wikipedia, der freien Enzyklopädie
Zur Navigation springen Zur Suche springen
OpenCL

OpenCL.jpg
Basisdaten

Entwickler Khronos Group
Erscheinungsjahr 28. August 2009
Aktuelle Version 2.2 official
(12. Mai 2017)
Aktuelle Vorabversion 2.2 provisional
(18. April 2016)
Betriebssystem plattformunabhängig
Programmiersprache C, C++
Kategorie Programmierschnittstelle
Lizenz verschieden
www.khronos.org/opencl

OpenCL (englisch Open Computing Language) ist eine Schnittstelle für uneinheitliche Parallelrechner, die z. B. mit Haupt-, Grafik- oder digitalen Signalprozessoren ausgestattet sind. Dazu gehört die Programmiersprache „OpenCL C“. OpenCL wurde ursprünglich von der Firma Apple entwickelt, um die Leistung der aktuellen Grafikprozessoren auch für nicht-grafische Anwendungen nutzbar zu machen.

In Zusammenarbeit mit den Firmen AMD, IBM, Intel und Nvidia wurde der erste Entwurf ausgearbeitet und schließlich von Apple bei der Khronos Group zur Standardisierung eingereicht.[1] Die Spezifikation für OpenCL 1.0 wurde am 8. Dezember 2008 veröffentlicht. Am 16. November 2011 folgte die Spezifikation 1.2 mit Verbesserungen, die zu 1.0 abwärtskompatibel bleibt. Zwei Jahre später, am 18. November 2013, wurde dann die OpenCL-2.0-Spezifikation eingeführt.

OpenCL 1.0 wurde erstmals am 28. August 2009 von Apple mit dem Betriebssystem Mac OS X Snow Leopard 10.6 auf den Markt gebracht, die dazugehörigen Programme („Kernel“) können zur Laufzeit auf verschiedene vorhandene OpenCL-fähige Geräte verteilt werden. Derzeit wird abhängig von der Hardware nur OpenCL 1.0 bis 1.2 von Apple unterstützt.[2][3]

Mit OpenCL 2.0 kompatible Hardware unterstützt mit aktualisierten Treibern auch die höheren Versionen 2.1 und 2.2 laut Khronos-Group.[4]

OpenCL 2.1 wurde im November 2015 offiziell freigegeben.[5] Eine entscheidende Neuerung in OpenCL 2.1 ist die Integration von SPIR-V, dem SPIR-Nachfolger (Standard Portable Intermediate Representation). SPIR-V ist eine Zwischensprache mit nativer Unterstützung für Grafik-Shader und Prozessor-Kernels. Sie ermöglicht die Aufteilung der Compiler-Kette auf die unterschiedlichen Recheneinheiten. Somit können High-Level-Sprachen über SPIR-V die heterogene Architektur ansprechen, ohne sich selbst um die Übersetzung auf die unterschiedlichen Hardware-Komponenten zu kümmern. SPIR-V wird außer in OpenCL auch in der Vulkan-Grafik-API genutzt.

OpenCL 2.2 wurde offiziell freigegeben im Mai 2017.[6][7] Als wichtigste Änderung nennt die Bekanntmachung die Integration der OpenCL C++ Kernel Language in OpenCL, was unter anderem beim Schreiben parallel arbeitender Programme helfen soll. Die im Rahmen der Open Computing Language als statische Untermenge des C++14-Standards definierte Kernel-Sprache enthält Klassen, Templates, Lambda-Ausdrücke und andere Konstrukte. Im Mai 2018 erschien ein Maintenance Update mit Bugfix und Aktualisierung in Headern von Spir-V.[8]

In Zukunft soll OpenCL als OpenCL-V ein Teil von Vulkan werden und so noch breitere Unterstützung gewinnen.[9][10] Zuletzt wurde nun OpenCL Next für 2019 angekündigt mit neuen Informationen.[11]

Architektur[Bearbeiten | Quelltext bearbeiten]

Plattform-Modell

Ein OpenCL-System besteht aus einem Host und einem oder mehreren OpenCL-Geräten. Ein Gerät besteht aus einer oder mehreren unabhängigen Recheneinheiten (englisch „compute unit“, kurz „CU“). Dies sind bei einem Mehrkernprozessor die verfügbaren Kerne, die zusammengefasst die Central Processing Unit ergeben, und für die Grafikkarte die Shader. Die Compute Unit ist in ein oder mehrere ausführende Elemente (englisch „processing element“, kurz „PE“) unterteilt. Der Host verteilt dabei die Kernel (dt. Kerne) zur Laufzeit auf die verfügbaren Geräte.

Es gibt zwei Arten von Kernel:

OpenCL-Kernel
Diese sind in der Programmiersprache OpenCL C geschrieben. OpenCL C basiert auf ISO C99 und wurde um Funktionen und Datentypen zur parallelen Verarbeitung erweitert.
Native Kernel
Diese Kernel sind optional und implementierungsspezifisch.

Die OpenCL-Kernel werden zur Laufzeit vom OpenCL-Compiler übersetzt und danach von einem OpenCL-Gerät ausgeführt. Hierdurch muss zur Entwicklungszeit nicht bekannt sein, auf welcher Hardware das Programm zur Laufzeit ausgeführt wird.

Die Berechnungen werden zur Laufzeit von den sogenannten Work-Items durchgeführt. Diese Work-Items werden zu einem ein-, zwei- oder dreidimensionalen Gitter angeordnet, über das die Work-Items adressiert werden können. Work-Items werden zu Work-Groups gruppiert, in denen eine Synchronisation möglich ist und die auf einen gemeinsamen Speicher zugreifen können. Ein einzelnes Work-Item kann also absolut, durch seine Koordinate und relativ, durch die Koordinate der es enthaltenden Work-Group und die Koordinate innerhalb der Work-Group angesprochen werden.

Speichermodell[Bearbeiten | Quelltext bearbeiten]

Speichermodell

In OpenCL werden fünf Arten von Speicher unterschieden:

  • Hostspeicher (host memory): Beim Hostspeicher handelt es sich um den regulären Arbeitsspeicher des Leitprogramms. Ein OpenCL-Kernel kann darauf nicht direkt zugreifen.
  • globaler Speicher (global memory): Hierbei handelt es sich um den Arbeitsspeicher der OpenCL-Kernel. Jede Instanz eines Kernels hat auf den gesamten Bereich wahlfreien Zugriff.
  • konstanter Speicher (constant memory): Der konstante Speicher unterscheidet sich vom globalen Speicher darin, dass die Kernelinstanzen diesen Speicher ausschließlich lesen, aber nicht verändern können.
  • lokaler Speicher (local memory): Eine Gruppe von Kernelinstanzen hat wahlfreien Zugriff auf einen kleinen Bereich von typischerweise 16 kiB lokalen Speicher. Jede Gruppe hat ihren eigenen Bereich, auf den jeweils nur die Mitglieder zugreifen können.
  • privater Speicher (private memory): Dieser Speicher ist einer Kernelinstanz vorbehalten. Andere Kernelinstanzen und das Leitprogramm können nicht auf den Inhalt dieses Speichers zugreifen.

OpenCL C[Bearbeiten | Quelltext bearbeiten]

Die Sprache OpenCL C basiert auf der Syntax von ISO C99, erweitert um zusätzliche Datentypen und Funktionen zur parallelen Verarbeitung, wurde an anderer Stelle aber auch eingeschränkt (siehe unten). Es handelt sich somit nicht um eine Obermenge von C, dennoch haben beide Sprachen viele Gemeinsamkeiten.

Ergänzend zu den C99-Datentypen unterstützt OpenCL C folgende Datentypen:

  • half: 16 Bit Gleitkommazahlen nach IEEE 754r.
  • Vektordatentypen: Die Datentypen char, uchar, short, ushort, int, uint, long, ulong und float gibt es als Vektoren mit 2, 4, 8 und 16 Elementen. Die Elementanzahl wird hierbei an den Namen der Datentypen angehängt, also z. B.: uchar4, float8 oder int16. Mit OpenCL 1.1 wurden zusätzlich drei-elementige Vektoren eingeführt.
  • image2d_t: Ein zweidimensionales Bild.
  • image3d_t: Ein dreidimensionales Bild.
  • sampler_t: Ein sampler, der definiert, wie ein Bild abgetastet wird.
  • event_t: Ein "event handler".

Folgende Datentypen wurden zudem für spätere Versionen von OpenCL reserviert:

  • booln: Ein Vektor mit Wahrheitswerten.
  • double, doublen: 64-Bit-Gleitkommazahlen und -vektoren. Eine Erweiterung für double existiert bereits, deren Unterstützung ist aber bei OpenCL 1.0 nicht erforderlich.
  • halfn: Ein Vektor mit 16-Bit-Gleitkommazahlen.
  • quad, quadn: 128-Bit-Gleitkommazahlen.
  • complex {half | float | double | quad}: Komplexe Zahlen mit unterschiedlicher Genauigkeit.
  • complex {half | float | double | quad}n: Vektoren komplexer Zahlen mit unterschiedlicher Genauigkeit.
  • imaginary {half | float | double | quad}: Imaginäre Zahlen mit unterschiedlicher Genauigkeit.
  • imaginary {half | float | double | quad}n: Vektoren imaginärer Zahlen mit unterschiedlicher Genauigkeit.
  • {float | double}nxm: nxm Matrizen mit 32 oder 64 Bit Genauigkeit.
  • long double, long doublen: Gleitkommazahlen und -vektoren mit mindestens der Genauigkeit von double und maximal der Genauigkeit von quad.
  • long long, long longn: Vorzeichenbehaftete 128-Bit-Ganzzahlen und -vektoren.
  • unsigned long long, unsigned long longn: Vorzeichenlose 128-Bit-Ganzzahlen und -vektoren.

Arithmetische Operationen (+, -, *, /, %, ++, --), Vergleichsoperationen (>, >=, ==, !=, <= <), Bitoperatoren (&, |, ^, ~) sowie logische Operatoren (&&, ||) sind sowohl für skalare Datentypen definiert als auch für Vektoren. Werden sie auf Vektoren angewendet, so wird die Operation komponentenweise durchgeführt. Hier verhält sich OpenCL analog zu bekannten Shadersprachen wie zum Beispiel GLSL.

Ebenfalls den Shader-Sprachen entlehnt sind eine Reihe mathematischer Funktionen, die ebenfalls komponentenweise durchgeführt werden, beispielsweise Sinus, Cosinus, Wurzel, Minimum, Maximum etc.

Gegenüber C ist OpenCL C unter anderem in folgenden Punkten eingeschränkt:

  • Es gibt keine Funktionszeiger
  • Rekursion ist nicht möglich.
  • Felder ("arrays") dürfen keine variable Länge haben.

Nutzung von OpenGL- und DirectX-Objekten[Bearbeiten | Quelltext bearbeiten]

OpenCL kann direkt auf Objekte von OpenGL oder DirectX (nur unter Windows) zugreifen, etwa auf Texturen. Somit kann OpenCL genutzt werden, um beispielsweise Texturen zu ändern, ohne die Daten extra umkopieren zu müssen.

Erweiterungen[Bearbeiten | Quelltext bearbeiten]

Wie OpenGL kann auch OpenCL durch herstellerspezifische Erweiterungen um zusätzliche Funktionen ergänzt werden. Beispiele für bereits definierte Erweiterungen sind:

  • Gleitkommazahlen mit doppelter Genauigkeit (64-Bit-Gleitkommazahlen, cl_khr_fp64).
  • Vektoren von Gleitkommazahlen mit halber Genauigkeit (16-Bit-Gleitkommazahlen, cl_khr_fp16).
  • Die Art des Rundens bei Gleitkommaoperationen zu definieren (cl_khr_select_fprounding_mode).
  • Schreiben in 3D-Bilder (cl_khr_3d_image_writes).

Implementierungen[Bearbeiten | Quelltext bearbeiten]

OpenCL kann für beliebige Betriebssysteme und Hardwareplattformen – genau wie OpenGL und OpenAL – implementiert werden. So ist in der Spezifikation von CPUs, GPUs, DSPs und dem Cell-Prozessor die Rede. Es existiert zudem eine Spezifikation für eingebettete Systeme mit reduzierten Anforderungen.

  • LLVM: Die OpenCL-Implementierungen von Nvidia, Intel und Apple setzen technisch auf LLVM auf, einer Technologie, die Apple in macOS ab Version 10.5 in seinem JIT-OpenGL-Compiler[12] und auch im IOS für Apple iPhone und Ipad einsetzt.
  • Nvidia OpenCL mit CUDA: Nvidia bietet eine OpenCL-Implementierung für seine GPGPU-Schnittstelle CUDA unter Linux, Windows und macOS an.[13] Die Generation der Tesla-Chips G80 und GT200 (Nvidia Tesla) unterstützt OpenCL 1.1 mit aktuellen Treibern ab Version 341.95.[14] Fermi unterstützt OpenCL 1.1. Maximal wird OpenCL 1.2 unterstützt in den Chips der Kepler- und Maxwell-GPU zum Beispiel mit den Nvidia-Geforce-700-Serie und Nvidia-Geforce-900-Serie, sowie auch in der Quadro-Serie.[15] Auch die neue Pascal-GPU unterstützt nur OpenCL 1.2 in der GeForce-10-Reihe wie auch in der Quadro und Tesla-Serie mit den bisherigen Treibern der 370er-Reihe. Mit der Treiber-Version 378.66 wird erstmals OpenCL 2.0 als Beta in wichtigen Funktionen unterstützt.[16]
  • Intel Beignet: Intel hat neben seiner kommerziellen SDK (2.0 für GPU und 2.1 für CPU ab Gen7)[21][22][23][24] für Linux und Android das Open Source Projekt Beignet (von Intel China) aufgesetzt.[25][26] Zuletzt wurde im November 2016 nach der schon längeren Unterstützung von OpenCL 1.2 (ab Ivy Bridge) die Unterstützung von OpenCL 2.0 angekündigt.[27] Aktuell ist Version 1.3.2 mit optionalem OpenCL 2.0 mit Optimierungsbedarf.
  • Intel NEO: Unter dem Codenamen NEO wurde ein neuer Open-Source-Treiber für Hardware ab Skylake entwickelt mit aktuell OpenCL 2.1-Unterstützung (neu ab Broadwell).[28] OpenCL 2.2 soll in "Compute Runtime" zeitnah noch 2018 folgen.[29]
  • AMD Stream Compute: Die OpenCL-Implementierung von AMD ermöglicht die Nutzung von GPUs über ihre GPGPU-Schnittstelle ATI-Stream und von CPUs mit SSE3 für Linux und Windows.[30] Ab der R700-Baureihe wird OpenCL 1.0 unterstützt und mit den nachfolgenden R800 und R900 mit der Terascale 2-Architektur OpenCL 1.2. Die aktuellere AMD GCN-Architektur 1.0 ist bisher in den Treibern auf OpenCL 1.2 limitiert. GCN 1.1, 1.2 und 1.3 unterstützen voll OpenCL 2.0 und damit auch zukünftig mit neueren Treibern die Versionen 2.1 und 2.2 mit vielen 28-nm-Prozessoren in der AMD-Radeon-HD-7000-Serie, AMD-Radeon-R200-Serie und AMD-Radeon-R300-Serie. Die neuen RX400- und RX500-Serien im 14-nm-Prozess unterstützen als 4. GCN-Generation (Arctic Islands) OpenCL 2.0 voll und damit auch mit späteren Treibern auch 2.1 und 2.2.[31] Auf Windows wird mit dem aktuellen Treiber 19.1.1 nun auch OpenCL 2.1 unterstützt. Unklar ist hier, welche Hardware schon hier profitieren kann. Vega-Chips können aktuell nur bis OpenCL 2.0 agieren.[32]

Opensource:

  • GalliumCompute (Clover): Mit Clover[34] ist seit Mitte 2011 eine unter der GPL stehende Implementierung für Linux in der Entwicklung, die ebenfalls auf LLVM aufsetzt und eine CPU oder – indirekt über Mesa 3D – eine Grafikkarte nutzen soll. Clover wurde in das Mesa-Projekt integriert und ist Teil von GalliumCompute.[35] Im Gegensatz zum folgenden ARM-Ableger Shamrock werden viele Tests für OpenCL 1.0 bis 1.2 noch nicht bestanden.
  • Shamrock: Ein Ableger von Clover für Android ARM V7+ ist Shamrock.[36][37] OpenCL 1.2 wird voll unterstützt. Der Khronos-Test wurde mit der "OpenCL 2.0 Samples Suite" für die Beispiele bis 1.2 zuletzt bestanden.
  • ROCm: Im Rahmen der Initiative OpenCompute hat AMD auch mit anderen das Projekt ROCm gestartet. Dazu wird jedoch relativ neue Hardware benötigt. (A new open source Linux Compute project is Radeon Open Compute ROCm for Radeon Graphics GCN 3, 4 und 5 (Hawaii, Fiji, Polaris, Vega) and Intel Gen7.5+ CPU (Haswell+) or new AMD Ryzen with PCIe 3.0.) Der Funktionsumfang von OpenCL 1.2 mit Sprachelementen von 2.0 wird unterstützt. Mit Version 1.8.x und 1.9.2 werden experimentell auch Prozessoren mit PCIe 2.0 mit moderner AMD-GCN-GPU ab 3. Generation mit dann geringerer Performance unterstützt. Mit der Version 2.0 wurde nun endlich auch OpenCL 2.0 und auch neue Hardware der Vega-Reihe unterstützt. Dazu gibt viele weitere Verbesserungen im Detail und in der Leistung. Für einige Tests und Benchmarks sind jedoch noch erhebliche Verbesserungen nötig, um die vorhandene Leistungsfähigkeit der Hardware auszunutzen wie im Vergleich der Karten und Software von NVIDIA.[38][39][40][41][42][43] Aktuell ist die Version 2.2 mit einigen Leistungsverbesserungen.[44]
  • POCL: Portable OpenCL (OpenCL 1.2 fast komplett mit Version 1.0, OpenCL 2.0 überwiegend)[45], in der Version 1.0 mit experimentellem Nvidia Cuda Backend für die Nutzung von Nvidia GPUs. Damit ist Open Source OpenCL auf Nvidia Hardware möglich mit erheblich mehr Möglichkeiten als bei Mesa.[46][47][48] Die Performance ist durch fehlende Optimierung und Software teilweise schwach mit Faktor 1:5 bis 1:10 zur AMD Windows Implementierung. Mit POCL 1.1 wird die Performance zum Teil stark verbessert und SPIR mit SPIR-V experimentell unterstützt.[49] Mit Version 1.2 wird HWOC 2.0 sowie nun OpenCL 1.2 komplett unterstützt.[50][51][52][53]
  • triSYCL: Freie OpenCL 2.2 Implementierung mit SYCL[54]

Eine Liste zertifizierter Produkte liegt bei Khronos vor.[55]

Diese müssen wie die Implementierungen die Tests der Khronos Conformance Test Suite (CTS) bestehen.[56]

Anwendungssoftware[Bearbeiten | Quelltext bearbeiten]

Viele rechenintensive Programme nutzen OpenCL zur Beschleunigung:[57]

Grafikprogramme[Bearbeiten | Quelltext bearbeiten]

  • FAST: Bildverarbeitung für Medizinanwendungen[75]
  • KLMeansCL: Entrauscher Plugin für AVISynth[76]
  • UFO: Bildverarbeitung von Synchrotron-Spuren[77]

3D-Renderer[Bearbeiten | Quelltext bearbeiten]

Audio[Bearbeiten | Quelltext bearbeiten]

  • CUETools: Mit dem CUERipper von den CUETools können die FLAC-Dateien besonders schnell mit der Funktion FLACCL von WAV-Format in FLAC konvertiert werden mit der Nutzung von OpenCL in den modernen Grafikkarten.[82] Dabei sind Beschleunigungen von Faktor 10 bis 100 für diesen Teil des Rip-Prozesses möglich abhängig von schnellen Grafikkarten und SSD-Datenspeichern gegenüber normaler CPU und Festplatte.
  • CN24: semantisches Analysewerkzeug[83]

Video[Bearbeiten | Quelltext bearbeiten]

Simulation[Bearbeiten | Quelltext bearbeiten]

  • Advanced Simulation Library[96]
  • SecondSpace OpenCL-Programm zur Simulation von Wellen im 2D-Raum.
  • PATRIC Particle-in-cell-Code[97]
  • Bullet: GPU rigid body simulation using OpenCL[98][99]
  • Monte-Carlo Simulation on AM57x[100]
  • Intel Demo Real-Time Shallow Water Simulation[101][102]
  • Intel Code Samples[103]
  • GROMACS molekulare Simulationen ab Version 5.1[104][105]
  • FEM: SIEMENS NX Nastran 9.1+ und Simulia Abaqus 6.11+[106][107][108][109]
  • Neuronale Netze: clgen: Deep Learning Program Generator[110]
  • Neuronale Netze: nengo_ocl Gehirn-Simulationen mit Nengo[111]
  • Entschlüsselung: JohnTheRipper[112]

Web[Bearbeiten | Quelltext bearbeiten]

Bibliotheken[Bearbeiten | Quelltext bearbeiten]

  • AMGCL: AMG algebraischer Multi-Grid Solver[120]
  • ArrayFire: is for parallel computing with an easy-to-use API with JIT-Compiler (Open Source)[121]
  • Bolt: STL compatible library for creating accelerated data parallel applications[122]
  • Boost.Compute: GPU/Parallel C++ Library für OpenCL[123]
  • Chlorine: C++11 Bibliothek zum einfachen Nutzen von OpenCL 1.2+[124]
  • CLBlast: getuntes clBlas[125]
  • clMAGMA: OpenCL port of the MAGMA project, a linear algebra library similar to LAPACK but for Multicore+GPU Systems[126][127]
  • DeepCL: Bibliothek für neurales Training[128]
  • GEGL-OpenCL: Gimp GEGL mit OpenCL[129]
  • GpyFFT: Python Wrapper for FFT mit clFFT[130]
  • MOT: Maastricht Optimization Toolbox[131]
  • Neanderthal: BLAS und LAPACK Implementierung für Clojure[132]
  • Netlib BLAS[133] mehr in BLAS
  • OpenCLGA: genetische Algorithmen mit PYOpenCL[134]
  • PARALUTION[135]
  • random123: Kollektion von Zufallszahlengeneratoren (counter-based random number generators (CBRNGs))[136]
  • VexCL: vector expression template library (MIT-Lizenz)[137]
  • ViennaCL: freie Open-Source Linear Algebra Bibliothek der TU Wien[138]
  • HIP: OpenSource C++ Toolkit für OpenCL und Cuda[139]
  • Projekt Coriander: Konvertierung von CUDA in OpenCL 1.2 mit CUDA-on-CL[140][141]
  • Projekt TF-Coriander: Tensorflow mit OpenCL 1.2[142]

Sprachen Kopplung[Bearbeiten | Quelltext bearbeiten]

  • ClojureCL: parallel OpenCL 2.0 mit Clojure[143]
  • dcompute: natives Ausführen von D[144]
  • Erlang OpenCL Binding[145]
  • OpenCLAda: Binding Ada zu OpenCL[146]
  • OpenCL.jl: Julia Bindings[147]
  • PyOpenCL: Python Kopplung[148]
  • Javascript: WebCL

Weblinks[Bearbeiten | Quelltext bearbeiten]

  • OpenCL bei der Khronos Group – Offizielle Webseite (englisch)
  • OpenCL bei AMD (englisch)
  • OpenCL bei Intel (englisch)
  • OpenCL bei Nvidia (englisch)
  • OpenCL bei Texas Instruments (englisch)


Tutorials

Einzelnachweise[Bearbeiten | Quelltext bearbeiten]

  1. Khronos OpenCL API Registry Spezifikation und Headerdateien (englisch)
  2. " Heise: OpenCL im Mac" Heise: OpenCL auf dem Mac im Jahr 2014
  3. "Apple-Support: OpenCL auf dem Mac-Rechnern" nur OpenCL 1.0 bis 1.2 auf den macOS-Rechnern, kein OpenCL 2.x (Stand April 2016)
  4. " Khronos OpenCL Overview 2.1" PDF mit Überblick von OpenCL 2.1 in Englisch
  5. https://www.heise.de/developer/meldung/Khronos-aktualisiert-Spezifikationen-fuer-OpenCL-2-1-und-SPIR-V-1-0-2922960.html
  6. https://www.heise.de/developer/meldung/Khronos-veroeffentlicht-vorlaeufige-Spezifikation-fuer-OpenCL-2-2-3177422.html
  7. https://www.khronos.org/news/permalink/khronos-releases-opencl-2.2-with-spir-v-1.2
  8. https://www.khronos.org/blog/opencl-2.2-maintenance-update-released
  9. https://www.pcper.com/reviews/General-Tech/Breaking-OpenCL-Merging-Roadmap-Vulkan
  10. http://www.phoronix.com/scan.php?page=news_item&px=IWOCL-2017-OpenCL
  11. https://www.phoronix.com/scan.php?page=article&item=siggraph-2018-khr&num=2
  12. Chris Lattner: A cool use of LLVM at Apple: the OpenGL stack. 15. August 2006 (LLVM-Chefentwickler, Apple-Angestellter)
  13. Nvidia zu OpenCL (28. September 2009)
  14. http://de.download.nvidia.com/Windows/Quadro_Certified/341.95/341.95-win8-win7-winvista-quadro-grid-release-notes.pdf
  15. http://de.download.nvidia.com/Windows/Quadro_Certified/368.39/368.39-win10-quadro-grid-release-notes.pdf
  16. https://streamcomputing.eu/blog/2017-02-22/nvidia-enables-opencl-2-0-beta-support/
  17. ARM Introduces New Graphics Processor with OpenCL Support. 10. Oktober 2010
  18. Intel springt mit „Sandy Bridge“ auf den OpenCL-Zug auf. 13. August 2010
  19. S3 Graphics launched the Chrome 5400E embedded graphics processor. 27. Oktober 2009
  20. VIA Brings Enhanced VN1000 Graphics Processor. 10. Dezember 2009
  21. http://www.phoronix.com/scan.php?page=news_item&px=Intel-OpenCL-SDK-Linux-2016R2
  22. https://software.intel.com/en-us/articles/whats-new-code-builder-2016-r2
  23. https://software.intel.com/en-us/whats-new-code-builder-2016-r3
  24. https://software.intel.com/en-us/blogs/2017/07/28/2017-opencl-whats-new
  25. https://www.freedesktop.org/wiki/Software/Beignet/
  26. http://www.phoronix.com/scan.php?page=news_item&px=Intel-Beignet-Android
  27. http://www.phoronix.com/scan.php?page=news_item&px=Beignet-Birthday-CL2
  28. https://github.com/intel/compute-runtime/releases
  29. Michael Larabel: Intel Open-Sources LLVM Graphics Compiler, Compute Runtime With OpenCL 2.1+. phrononix, 16. Februar 2018, abgerufen am 22. April 2018.
  30. AMD zu ATI Stream und OpenCL (1. Oktober 2009)
  31. https://www.amd.com/en/support/kb/release-notes/rn-pro-win-18-7-1
  32. https://www.geeks3d.com/20190111/amd-adrenalin-2019-edition-19-1-1-released-with-better-fortnite-support-and-vulkan-1-1-96/
  33. OpenCL Development Kit for Linux on Power (30. Oktober 2009)
  34. Website des Clover-Projekts, Blog des Clover Entwicklers
  35. https://www.x.org/wiki/Events/XDC2013/XDC2013TomStellardCloverStatus/XDC2013TomStellardCloverStatus.pdf
  36. https://s3.amazonaws.com/connect.linaro.org/lca14/presentations/LCA14-412-%20GPGPU%20on%20ARM%20SoC%20session.pdf
  37. https://git.linaro.org/gpgpu/shamrock.git/about/
  38. https://github.com/RadeonOpenCompute/ROCm
  39. https://www.heise.de/newsticker/meldung/AMD-auf-der-Supercomputing-Konferenz-SC16-OpenCompute-mit-ROCm-aber-kein-Zen-3491050.html
  40. https://www.heise.de/developer/artikel/House-of-ROC-AMDs-Alternative-zu-CUDA-3755863.html
  41. https://www.phoronix.com/scan.php?page=news_item&px=ROCm-Compute-Stack-Overview
  42. https://www.phoronix.com/scan.php?page=article&item=rocm19-nvidia415-compute&num=2
  43. https://www.phoronix.com/scan.php?page=article&item=radeon-rocm-20&num=1
  44. https://www.phoronix.com/scan.php?page=news_item&px=Radeon-ROCm-2.2-Released
  45. http://portablecl.org/docs/html/features.html#
  46. http://portablecl.org/cuda-backend.html
  47. https://www.phoronix.com/scan.php?page=article&item=pocl10-epyc-xeon&num=1
  48. http://portablecl.org/pocl-1.0.html
  49. http://portablecl.org/pocl-1.1.html
  50. http://portablecl.org/pocl-1.2.html
  51. https://github.com/pocl/pocl/wiki/OpenCL-1.2-missing-features
  52. https://github.com/pocl/pocl/issues?q=milestone%3A1.2+is%3Aclosed
  53. https://github.com/pocl/pocl/releases
  54. https://github.com/triSYCL/triSYCL
  55. https://www.khronos.org/conformance/adopters/conformant-products#opencl
  56. https://github.com/KhronosGroup/OpenCL-CTS
  57. http://www.amd.com/de-de/solutions/professional/hpc/opencl
  58. https://www.khronos.org/news/permalink/gimp-2.8-rc-1-includes-opencl-acceleration
  59. http://www.tomshardware.de/photoshop-cs6-gimp-aftershot-pro-opencl-opengl,testberichte-241066-5.html
  60. https://www.phoronix.com/scan.php?page=news_item&px=More-GEGL-OpenCL-Support
  61. https://wiki.gimp.org/wiki/Roadmap
  62. http://www.amd.com/en-us/press-releases/Pages/amd-and-adobe-creative-suite-6-2012apr23.aspx
  63. http://www.tomshardware.de/photoshop-cs6-gimp-aftershot-pro-opencl-opengl,testberichte-241066-6.html
  64. ImageMagick: Architecture. Abgerufen am 7. August 2015.
  65. http://www.imagemagick.org/script/opencl.php
  66. http://www.agisoft.com/downloads/system-requirements/
  67. http://cgpress.org/archives/cgreviews/photoscan-review/2
  68. http://www.darktable.org/2012/03/darktable-and-opencl/
  69. https://www.darktable.org/usermanual/ch10s02s07.html.php
  70. http://www.phoronix.com/scan.php?page=article&item=darktable-opencl-gpu&num=1
  71. http://www.phoronix.com/scan.php?page=article&item=darktable-22-amdnv&num=1
  72. http://www.blurate.com/
  73. http://www.halcon.com/
  74. http://www.tomshardware.de/photoshop-cs6-gimp-aftershot-pro-opencl-opengl,testberichte-241066-12.html
  75. https://github.com/smistad/FAST
  76. https://github.com/Khanattila/KNLMeansCL
  77. http://ufo-core.readthedocs.io/en/latest/using/index.html
  78. http://semiaccurate.com/2012/06/11/amd-and-autodesk-speed-up-maya-with-opencl/
  79. http://streamcomputing.eu/blog/2013-12-28/professional-consumer-media-software-opencl/
  80. http://developer.amd.com/community/blog/2015/07/10/collaboration-and-open-source-at-amd-blender-cycles/
  81. https://wiki.luxcorerender.org/LuxMark
  82. Vergleich Konvertierung mit CPU Core i7 und verschiedenen GPU mit FLACCL
  83. https://github.com/cvjena/cn24
  84. https://handbrake.fr/news.php?article=27
  85. Heise: FFmpeg mit OpenCL
  86. http://support.apple.com/en-us/HT202239
  87. http://streamcomputing.eu/blog/2013-12-28/professional-consumer-media-software-opencl/
  88. http://streamcomputing.eu/blog/2013-12-28/professional-consumer-media-software-opencl/
  89. http://streamcomputing.eu/blog/2013-12-28/professional-consumer-media-software-opencl/
  90. http://www.sonycreativesoftware.com/de/
  91. http://www.vegascreativesoftware.com/de/
  92. https://s-a-m.com/products/alchemist-xf-%E2%80%93-highest-quality-file-based-format-and-framerate-conversion-software/c-24/p-228
  93. http://www.tomshardware.com/reviews/opencl-simhd-vreveal,3122-11.html
  94. http://www.tomshardware.de/opencl-simhd-vreveal,testberichte-240965.html
  95. http://www.tomshardware.de/opencl-simhd-vreveal,testberichte-240965-3.html
  96. http://asl.org.il/
  97. http://web-docs.gsi.de/~sappel/diplomarbeit_jutta_fitzek.pdf
  98. http://www.multithreadingandvfx.org/course_notes/GPU_rigidbody_using_OpenCL.pdf
  99. http://bulletphysics.org/wordpress/
  100. http://www.ti.com/lit/ug/tiduar9/tiduar9.pdf
  101. https://www.khronos.org/assets/uploads/developers/library/2011_GDC_OpenCL/Intel-OpenCL-Water-Sim_GDC-Mar11.pdf
  102. https://software.intel.com/sites/default/files/managed/2c/79/intel_ocl_shallow_water_win.zip
  103. https://software.intel.com/en-us/intel-opencl-support/code-samples
  104. http://manual.gromacs.org/documentation/5.1/install-guide/index.html#opencl-gpu-acceleration
  105. https://github.com/StreamComputing/gromacs
  106. http://www.cadplace.de/Hardware/Hardware-allgemein/OpenCL-bietet-Simulationsperformance-fuer-Nastran-und-Abaqus
  107. https://www.amd.com/Documents/abaqus-solution-sheet.pdf
  108. https://www.amd.com/Documents/nastran-solution-sheet.pdf
  109. https://community.plm.automation.siemens.com/siemensplm/attachments/siemensplm/Femap-tkb/105/1/FS16_Saratech_04_PerformanceTuning.pdf
  110. https://github.com/ChrisCummins/clgen
  111. https://github.com/nengo/nengo_ocl
  112. https://github.com/magnumripper/JohnTheRipper
  113. http://techcrunch.com/2014/03/19/webcl-will-soon-let-web-developers-harness-the-power-of-multi-core-gpus-and-cpus-from-the-browser/
  114. http://techcrunch.com/2014/03/19/webcl-will-soon-let-web-developers-harness-the-power-of-multi-core-gpus-and-cpus-from-the-browser/
  115. http://developer.amd.com/tools-and-sdks/opencl-zone/acl-amd-compute-libraries/
  116. https://github.com/clMathLibraries/clBLAS
  117. https://github.com/clMathLibraries/clSPARSE
  118. https://github.com/clMathLibraries/clFFT
  119. https://github.com/clMathLibraries/clRNG
  120. https://github.com/ddemidov/amgcl
  121. http://arrayfire.com/
  122. http://developer.amd.com/tools-and-sdks/opencl-zone/bolt-c-template-library/
  123. https://github.com/boostorg/compute
  124. https://github.com/Polytonic/Chlorine
  125. https://github.com/CNugteren/CLBlast
  126. http://icl.cs.utk.edu/magma/software/view.html?id=207
  127. http://www.icl.utk.edu/sites/icl/files/print/2015/magma-sc15.pdf
  128. https://github.com/hughperkins/DeepCL
  129. https://github.com/OpenCL/GEGL-OpenCL
  130. https://github.com/geggo/gpyfft
  131. https://github.com/cbclab/MOT
  132. https://github.com/uncomplicate/neanderthal
  133. http://www.netlib.org/blas/index.html
  134. https://github.com/PyOCL/OpenCLGA
  135. http://www.paralution.com/
  136. http://www.thesalmons.org/john/random123/releases/latest/docs/index.html
  137. https://github.com/ddemidov/vexcl
  138. http://viennacl.sourceforge.net/
  139. https://github.com/GPUOpen-ProfessionalCompute-Tools/HIP
  140. http://www.phoronix.com/scan.php?page=news_item&px=CUDA-On-CL-Coriander
  141. http://www.iwocl.org/wp-content/uploads/iwocl2017-hugh-perkins-cuda-cl.pdf
  142. https://github.com/hughperkins/tf-coriander
  143. https://github.com/uncomplicate/clojurecl
  144. https://github.com/libmir/dcompute
  145. https://github.com/tonyrog/cl
  146. https://github.com/flyx/OpenCLAda
  147. https://github.com/JuliaGPU/OpenCL.jl
  148. https://github.com/pyopencl/pyopencl