OpenCL

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
OpenCL
Entwickler Khronos Group
Aktuelle Version 2.0
(18. November 2013)
Betriebssystem plattformunabhängig
Kategorie Programmierschnittstelle
Lizenz verschieden
www.khronos.org/opencl/

OpenCL (Open Computing Language) ist eine Schnittstelle für uneinheitliche Parallelrechner, die z. B. mit Haupt-, Grafik- oder digitalen Signalprozessoren ausgestattet sind und mit der zugehörigen Programmiersprache „OpenCL C“. Sie wurde entwickelt, um die Leistung der aktuellen Grafikprozessoren auch für nicht-grafische Anwendungen nutzbar zu machen.

Sie ist ursprünglich von der Firma Apple entwickelt worden. 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 10.6 (Snow Leopard) auf den Markt gebracht, die dazugehörigen Programme (so genannte Kernel) können zur Laufzeit auf verschiedene vorhandene OpenCL-fähige Geräte verteilt werden.

Architektur[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 über einen gemeinsamen Speicher verfügen 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]

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]

Die Sprache OpenCL C basiert auf der Syntax von ISO C99 und wurde um weitere Datentypen und Funktionen zur parallelen Verarbeitung erweitert, 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 3-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 zwingend 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-Integerzahlen und -vektoren.
  • unsigned long long, unsigned long longn: Vorzeichenlose 128-Bit-Integerzahlen 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 Shadersprachen entlehnt sind eine Reihe von mathematischen 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 Pointer auf Funktionen.
  • Rekursion ist nicht möglich.
  • Arrays dürfen keine variable Länge haben.

Nutzung von OpenGL- und DirectX-Objekten[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]

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]

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.

Nvidia bietet eine OpenCL-Implementierung für seine GPGPU-Schnittstelle CUDA unter Linux, Windows und Mac OS X an.[2] Weitere Implementierungen für GPUs kommen von ARM,[3] Intel,[4] S3[5] und VIA.[6] 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.[7] IBM bietet eine Implementierung für die Power-Architektur und die Cell Broadband Engine an.[8]

Die OpenCL-Implementierungen von Nvidia, Intel und Apple setzen technisch auf LLVM auf, einer Technologie, die Apple in OS X seit Version 10.5 in seinem JIT-OpenGL-Compiler[9] und auch im Apple iPhone einsetzt.

Mit Clover[10] 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.

Weblinks[Bearbeiten]

Tutorials
Programme
  • SecondSpace OpenCL-Programm zur Simulation von Wellen im 2D-Raum.

Einzelnachweise[Bearbeiten]

  1. Khronos OpenCL API Registry (englisch) – Spezifikation und Headerdateien
  2. Nvidia zu OpenCL (28. September 2009)
  3. ARM Introduces New Graphics Processor with OpenCL Support (10. Oktober 2010)
  4. Intel springt mit Sandy Bridge auf den OpenCL-Zug auf (13. August 2010)
  5. S3 Graphics launched the Chrome 5400E embedded graphics processor (27. Oktober 2009)
  6. VIA Brings Enhanced VN1000 Graphics Processor (10. Dezember 2009)
  7. AMD zu ATI Stream und OpenCL (1. Oktober 2009)
  8. OpenCL Development Kit for Linux on Power (30. Oktober 2009)
  9. Chris Lattner (LLVM-Chefentwickler, Apple-Angestellter): A cool use of LLVM at Apple: the OpenGL stack (15. August 2006)
  10. Website des Clover-Projekts, Blog des Clover Entwicklers