OpenCL im Handel - Seite 9

[MetaQuotes]

EECE.6540 Heterogene Computing (University of Massachusetts Lowell) - 46. Grundlegende FPGA-Konzepte

46. Grundlegende FPGA-Konzepte

Dieses Video behandelt grundlegende Konzepte von feldprogrammierbaren Gate-Arrays (FPGAs). Im Gegensatz zu CPUs können FPGAs so programmiert werden, dass sie zu bestimmten Hardwareressourcen passen, was bedeutet, dass sie in hohem Maße anpassbar sind. Das Video diskutiert die Bedeutung der Latenz beim Schaltungsdesign und wie sie durch Maximieren von f max ausgeglichen werden kann. Es führt das Konzept des Pipeline-Designs ein, um die Häufigkeit zu erhöhen, mit der eine Berechnung durchgeführt werden kann, und diskutiert Datenpfade und Steuerpfade in einer Schaltung. Schließlich diskutiert das Video die Schaltungsbelegung in einem FPGA und wie abnehmende Blasen und zunehmende Belegung f max erhöhen können.

• 00:00:00 In diesem Abschnitt lernen wir die grundlegenden Konzepte von Field Programmable Gate Arrays (FPGAs) kennen und wie sie sich von anderen Prozessorarchitekturen unterscheiden. Im Gegensatz zu CPUs haben FPGAs keinen festen Datenpfad und können so programmiert werden, dass sie zu bestimmten Hardwareressourcen passen, um eine unterschiedliche Anzahl von Registern, Rechenlogik und deren Verbindungen aufzunehmen, wodurch sie hochgradig anpassbar sind. FPGAs enthalten verschiedene Komponenten wie adaptive Logik, RAM-Blöcke, DSP-Blöcke und programmierbare Routing-Schalter, die zur Implementierung verschiedener Designs verbunden werden können. Darüber hinaus wird die maximale Betriebsfrequenz eines FPGA durch die physikalische Ausbreitungsverzögerung der kombinatorischen Logik bestimmt, die sich auf die Latenz und die Betriebsgeschwindigkeit der Schaltung auswirkt.
  
  
• 00:05:00 In diesem Abschnitt wird das Konzept der Latenz und ihre Bedeutung im Schaltungsdesign erklärt. Die Latenz ist die Zeit, die eine Schaltung benötigt, um eine oder mehrere Operationen abzuschließen, und sie kann in Zeit oder Taktzyklen gemessen werden. Die Verringerung der Latenz ist normalerweise das Ziel, aber es muss sorgfältig mit der Maximierung von f max ausbalanciert werden. Es wird ein Beispiel für ein Design gegeben, das für Latenz optimiert ist, und eines, das durch Pipeline-Verwendung für f max optimiert ist. Die Wichtigkeit von Pipeline-Registern zum Aufbrechen langer kritischer Pfade und zum Verbessern der Geschwindigkeit wird betont.
  
  
• 00:10:00 In diesem Abschnitt erklärt das Video das Konzept des Pipeline-Designs und wie es die Häufigkeit erhöht, mit der eine Berechnung durchgeführt werden kann. Durch die Verwendung eines Pipeline-Registers kann die Verzögerung verkürzt werden, was höhere Taktgeschwindigkeiten und eine Erhöhung des Durchsatzes ermöglicht. Das Video stellt dann die Idee des Datenpfads und des Steuerpfads in einer Schaltung vor, wobei der Datenpfad die Kette von Registern und kombinatorischer Logik ist, die die Berechnung durchführt, und der Steuerpfad alles andere außerhalb des Datenpfads ist, das den Betrieb der Schaltung steuert . Verschiedene Logiken werden dem Steuerpfad unter anderem für Handshaking-Flusssteuerung, Schleifensteuerung und Verzweigungssteuerung hinzugefügt, und die Belegung wird verwendet, um das Initialisierungsverhältnis des Datenpfads in einer Schaltung zu definieren.
  
  
• 00:15:00 In diesem Abschnitt erläutert der Referent das Konzept der Schaltungsbelegung in einem FPGA. Die Schaltung hat mehrere Register, von denen eines ein gültiges Register ist, das bestimmt, ob die Eingangsdaten gültig sind oder nicht. Das Ziel besteht darin, Blasen im Kreislauf zu verringern, um die Belegung zu erhöhen, indem Blasen im gesamten Kreislauf minimiert werden. Jeder Zyklus wird gezählt, um zu sehen, wie Ressourcen verwendet werden, und unbesetzte Teile im Kreislauf werden Blasen genannt. Durch Verringern der Blasen und Erhöhen der Belegung kann f max erhöht werden.

[MetaQuotes]

47. Entwurfsanalyse (I): Analysieren von frühen FPGA-Bildern

47. Entwurfsanalyse (I): Analysieren von frühen FPGA-Bildern

Dieser Abschnitt des Videos konzentriert sich auf den Prozess der Analyse früher FPGA-Images für ein DPC++-Design. Der Referent erklärt die erforderlichen Schritte, wie das Kompilieren des Programms, das Generieren der FPGA-Binärdatei und das Ausführen der Profilerstellung. Das Video enthält eine Demo zur Generierung von Berichten und zur Interpretation der verschiedenen in den Berichten bereitgestellten Informationstafeln. Der Referent analysiert auch die frühen FPGA-Bilder eines b2-Moduls und diskutiert die verschiedenen Logikblöcke, Schleifen, Lasteinheiten und Unroll-Faktoren. Sie diskutieren auch, wie das Design einer Kernel-Funktion das interne Design auf FPGA erheblich beeinflussen kann, und liefern Beispiele dafür, wie die inneren und äußeren Schleifen entrollt werden können, um den Durchsatz zu erhöhen. Die Beispiele veranschaulichen die Flexibilität der Hochsprachenprogrammierung bei der Beeinflussung der Hardware-Ressourcen des FPGA.

• 00:00:00 In diesem Abschnitt des Videos erläutert der Sprecher den Prozess der Analyse eines DPC++-Designs, wobei er sich speziell auf die Analyse früher FPGA-Bilder konzentriert. Dies umfasst mehrere Schritte, z. B. das Kompilieren des Programms für einen FPGA-Emulator, um die funktionale Korrektheit sicherzustellen, das Generieren der FPGA-Binärdatei, das Ausführen auf einer Funktionskarte und das Ausführen von Profilen zur Bestimmung der Laufzeitleistung. In der zweiten Phase werden Berichte erstellt und nach Engpässen gesucht, bevor das Design gegebenenfalls überarbeitet wird. Das Video enthält eine Demo, wie Berichte erstellt und in einem Browser analysiert werden, und erklärt, wie die verschiedenen Informationsfelder und Zusammenfassungen in den Berichten zu interpretieren sind.
  
  
• 00:05:00 In diesem Abschnitt gibt der Referent einen Überblick über das Designanalyse-Tool und seine Funktionen. Sie erklären, wie das Ressourcenauslastungsfenster Informationen über die Ressourcen anzeigt, die vom Design verwendet werden, und wie das Systembetrachterfenster es Benutzern ermöglicht, verschiedene Komponenten des Designs anzuzeigen, wie z. B. Speicherkomponenten und Pipes. Der Diagramm-Viewer im System-Viewer-Bereich zeigt eine Liste der im Design verwendeten Komponenten und wie sie miteinander verbunden sind. Der Referent demonstriert auch, wie Benutzer in einzelne Module hineinzoomen können, um die entsprechenden Segmente im Quellcode anzuzeigen.
  
  
• 00:10:00 In diesem Abschnitt analysiert der Referent die frühen FPGA-Bilder eines b2-Moduls und erörtert die verschiedenen Logikblöcke und Schleifen, aus denen das Design besteht. Sie erklären auch die Verwendung der Ladeeinheit, um Daten aus der Speicherkomponente zu laden, und den Unroll-Faktor, um die Effizienz von Schleifenoperationen zu erhöhen. Der Referent vergleicht auch Parallel-4- und Single-Task-Designs und empfiehlt die Verwendung von Single-Task für FPGA-Designs, um den Speicherzugriff zu optimieren.
  
  
• 00:15:00 In diesem Abschnitt erörtert der Referent, wie das Design einer Kernel-Funktion das interne Design auf FPGA erheblich beeinflussen kann. Der Referent liefert Beispiele dafür, wie die inneren und äußeren Schleifen entrollt werden können, um die Hardware-Ressourcen des FPGA zu nutzen und dadurch den Durchsatz zu erhöhen. Die Beispiele veranschaulichen die Flexibilität der Hochsprachenprogrammierung bei der Beeinflussung der Hardware-Ressourcen des FPGA.

[MetaQuotes]

48. DPC++ FPGA-Entwurfsanalyse (II): Laufzeitprofilierung

48. DPC++ FPGA-Entwurfsanalyse (II): Laufzeitprofilierung

In diesem Video erläutert der Moderator den Prozess der Analyse der Laufzeitleistung eines Programms mithilfe von Tools, die Leistungsdaten sammeln, indem sie Profiling-Instrumentenregister zu den FPGA-Bitströmen hinzufügen. Sie demonstrieren, wie man für die Profilerstellung kompiliert und die kollektiven Profilerstellungsergebnisse mit dem dynamischen Intel FPGA-Profiler mit vom Benutzer hinzugefügten Leistungsindikatoren interpretiert. Sie zeigen, wie der V2-Profiler Kernelfunktionen und ausführbare Dateien anzeigt, die zum Analysieren von Laufzeit-Profiling-Ergebnissen verwendet werden, und wie Partitionsengpässe identifiziert und optimiert werden können. Das verwendete Beispiel ist ein Matrix-Modifikations-Kernel, der viele Speicherzugriffe auf den globalen Speicher hatte, der durch Verwendung des lokalen Speichers optimiert wurde, um die Kommunikation mit dem globalen Speicher zu reduzieren und die Entwurfseffizienz zu verbessern.

• 00:00:00 In diesem Abschnitt erörtert der Moderator die Analyse der Laufzeitleistung eines Programms. Sie erklären, wie Tools zum Sammeln von Leistungsdaten verwendet werden, indem den FPGA-Bitströmen Profiling-Instrumentenregister hinzugefügt werden. Der dynamische Intel FPGA-Profiler wird mit vom Benutzer hinzugefügten Leistungsindikatoren verwendet, um Kernelleistungsdaten zu sammeln. Die Leistungsdaten werden am Ende der Ausführung in einer Datei namens profile.mall gespeichert, und es wird eine JSON-Datei generiert, damit der Intel v2-Profiler die Dateien lesen kann. Beide Dateien werden beim Laden des Ergebnisordners in das Intel Retune-Toolkit benötigt. Das Importieren der Daten aus dem Verzeichnis ist wichtig, wenn Daten in v2 geladen werden.
  
  
• 00:05:00 In diesem Abschnitt demonstrieren die Referenten, wie man für die Profilerstellung kompiliert und die kollektiven Profilerstellungsergebnisse interpretiert. Sie zeigen, wie der V2-Profiler Kernelfunktionen und ausführbare Dateien anzeigt, die zum Analysieren von Laufzeit-Profiling-Ergebnissen verwendet werden. Das Panel zeigt Speicheroperationsfunktionen und Schleifenoperationen, deren Zeit, Verzögerungsprozentsatz, Belegung, Leerlaufzeit, Aktivitätsprozentsatz, Datenübertragungsgröße und durchschnittliche Bandbreite. Der untere Teil des Panels zeigt detaillierter die FPGA-Nutzung und andere Metriken für die Belegung der globalen Speicherbandbreite. Durch die Anzeige der detaillierten Statistiken können Designer einzelne Kernel und ihre Funktionen verstehen, was ihnen hilft, ihre Designs zu optimieren und zu verbessern.
  
  
• 00:10:00 In diesem Abschnitt des Videos erläutert der Sprecher, wie Partitionsengpässe identifiziert und optimiert werden können. Das verwendete Beispiel ist ein Matrix-Modifikations-Kernel, der viele Speicherzugriffe auf den globalen Speicher hat, was zu einer Datenübertragung von 15,57 GB führt. Das Design des Kernels ist speichergebunden, und die Lösung besteht darin, den Speicherzugriff zu optimieren, indem lokaler Speicher verwendet wird, um die Kommunikation mit dem globalen Speicher zu reduzieren und die Designeffizienz zu verbessern. Diese Optimierung wird in der nächsten Vorlesung behandelt.

[MetaQuotes]

EECE.6540 Heterogene Datenverarbeitung (University of Massachusetts Lowell) – 49. OpenCL-Beispiele

49. OpenCL-Beispiele (I)

Das YouTube-Video „OpenCL-Beispiele (I)“ behandelt die Implementierung der Matrixmultiplikation mit verschachtelten Schleifen in der C-Programmierung und ihre Implementierung als OpenCL-Kernel. Der Dozent erklärt, wie zwei Ebenen von verschachtelten Schleifen für die Punktproduktberechnung des resultierenden Elements in der Matrix verwendet werden und wie jedes Ausgabeelement von Matrix C als separates Arbeitselement in OpenCL behandelt wird. Das Video behandelt auch die Schritte, die erforderlich sind, um den OpenCL-Kernel für die Ausführung vorzubereiten und die resultierende Matrix von einem Gerät auf einen Host abzurufen, sowie das Festlegen von Arbeitsgruppengrößen und das Ausführen des Kernels mit modifizierten Kernel-Argumenten. Darüber hinaus wird ein Beispielcode für die Matrixmultiplikation bereitgestellt, und der Referent demonstriert den Prozess zum Abrufen von Geräte- und Plattform-IDs auf einem Mac OS und zum Erstellen eines Programmobjekts auf verschiedenen Plattformen. Schließlich erklärt das Video die Pufferverwaltung, verfolgt die auf der Hostseite zugewiesenen Ressourcen und die verwendeten OpenCL-Ressourcen und bietet ein einfaches Multiplikations-Kernel-Beispiel.

Dieses Video behandelt verschiedene Beispiele für die Verwendung von OpenCL, einschließlich Matrixmultiplikation, Bilddrehung und Bildfilterung. Bei der Bilddrehung erklärt der Referent, wie das Problem mithilfe der Eingabezerlegung gelöst werden kann, und demonstriert die Kernelfunktion, die zum Identifizieren der ursprünglichen und neuen Position jedes Pixels verwendet wird. Für die Bildfilterung erörtert der Referent das Konzept der Erstellung von Bildobjekten auf der Geräteseite und die Verwendung von OpenCL-Sampler, um zu definieren, wie auf das Bild zugegriffen wird. Sie präsentieren auch eine Beispielimplementierung der Bildfaltungsfunktion mit zwei verschachtelten for-Schleifen. Das Video schließt mit einer Demonstration der Verwendung von OpenCL, um einen Faltungsfilter auf ein Bild anzuwenden und die Ergebnisse zu überprüfen.

• 00:00:00 In diesem Abschnitt führt der Dozent in die Matrixmultiplikation ein, ein klassisches Computerbeispiel, und erklärt, wie sie durch verschachtelte Schleifen in der C-Programmierung implementiert werden kann. Sie erklären auch die Punktproduktberechnung des resultierenden Elements in der Matrix, das das Produkt einer Zeile aus Matrix A und einer Spalte aus Matrix B ist. Die Vorlesung erklärt, dass die beiden Ebenen von verschachtelten Schleifen unabhängig voneinander ausgeführt werden können und ausgeführt werden können auf zufällige Weise.
  
  
• 00:05:00 In diesem Abschnitt wird das Konzept des Arbeitselements und seine Anwendung zur Implementierung der Matrixmultiplikation im OpenCL-Kernel erörtert. Jedes Ausgabeelement von Matrix C wird als separates Arbeitselement behandelt, und mit Hilfe von FPGA- oder GPU-Verarbeitungselementen kann ein zweidimensionaler Bereich von Arbeitselementen auf andere for-Schleifen in der Hardwareimplementierung abgebildet werden. Um die Matrizenmultiplikation zu implementieren, wird eine Kernfunktion namens "simple multiply" mit einer Liste von Argumenten definiert, die alle notwendigen Eingabematrizen und ihre Dimensionen benötigt. Der Hauptteil der Kernel-Funktion verwendet globale IDs, um die zweidimensionale Position des Arbeitselements zu berechnen, und initialisiert die Summe, um das resultierende Element der Matrix C zu berechnen.
  
  
• 00:10:00 In diesem Abschnitt erläutert der Referent die Kernelfunktion für die Matrixmultiplikation unter Verwendung des OpenCL-Programmierframeworks. Die Kernfunktion verwendet eine Punktproduktoperation und eine for-Schleife, um die Elemente des Zeilenvektors von a und des Spaltenvektors von B zu durchlaufen. Die Indizes für die zweidimensionale Eingabematrix werden unter Verwendung der zu findenden Zeilennummern und Spaltennummern berechnet das rechte Element im Zeilenvektor und Spaltenvektor. Sobald das Skalarprodukt berechnet ist, wird das resultierende Element dem entsprechenden Element in C zugewiesen. Die Umgebung für die Berechnung wird ebenfalls besprochen, die plattformabhängig ist und das Verständnis der verfügbaren Ressourcen und wichtigen Parameter in der Plattform beinhaltet.
  
  
• 00:15:00 In diesem Abschnitt skizziert der Referent die Schritte, die erforderlich sind, um einen OpenCL-Kernel für die Arbeit vorzubereiten, beginnend mit der Erstellung eines Kontexts und einer Befehlswarteschlange, um Kernel zu instanziieren. Dann werden die Eingabedaten durch Zuweisen von Puffern auf der Hostseite, Kopieren von Daten aus dem Hostspeicher in den Gerätespeicher und Versenden des Kernels vorbereitet. Das Programm wartet dann auf die Kernel-Vervollständigung, um die Ergebnisse durch Lesen des Gerätespeichers zu sammeln. Die openCL-Anwendung hat zwei Schichten: die Plattformschicht und die Laufzeitschicht, und das Kernelprogramm muss in eine Binärdatei kompiliert werden, die auf dem Beschleunigergerät, entweder einem FPGA oder einer GPU, ausgeführt werden kann. Diese Schritte unterscheiden sich je nach Gerät, und die Kompilierung für eine PG-Binärdatei kann Stunden dauern, während die GPU-Kompilierung oft schnell ist.
  
  
• 00:20:00 In diesem Abschnitt erläutert das Video, wie die Umgebung für die OpenCL-Programmierung eingerichtet wird. Der erste Schritt beinhaltet das Abrufen der Plattform-ID, was mit der CL-Funktion get platform IDs erfolgt, die die Anzahl der im System verfügbaren Plattformen zurückgibt. Als nächstes erklärt das Video, wie Sie ein bestimmtes Gerät innerhalb der Plattform basierend auf Benutzerpräferenzen erhalten und wie Sie einen OpenCL-Kontext erstellen, der alle Ressourcen wie Befehlswarteschlangen und Puffer enthält. Das Tutorial empfiehlt, den Rückgabewert zu überprüfen, um den Erfolg der Operation sicherzustellen.
  
  
• 00:25:00 In diesem Abschnitt erklärt das Video, wie Daten aus den Eingabematrizen B und C und der Ausgabematrix C erstellt und verschoben werden, indem Puffer deklariert und OpenCL-API-Funktionen verwendet werden. Sie gehen davon aus, dass die Matrizen A, B und C bereits als Float-Typ-Arrays deklariert wurden, und speichern die Daten im linearen Adressraum im physischen Speicher. Das Video demonstriert die Verwendung der CL-Create-Buffer-Funktion zum Deklarieren von Puffern für die Matrizen A und B und die CL Inc-You-Write-Buffer-Funktion zum Kopieren der Anfangsdaten aus den Matrizen A und B in die erstellten Puffer, die sich auf dem Gerät befinden. Der nächste Schritt besteht darin, Platz für Matrix C zuzuweisen, die als Nur-Schreib-Puffer des CL-Speichers deklariert ist, da das Gerät die Berechnungsergebnisse in sie schreibt.
  
  
• 00:30:00 In diesem Abschnitt des YouTube-Videos „OpenCL-Beispiele (I)“ erläutert der Referent den Vorgang des Abrufens von Ergebnissen von einem Gerät und das Kopieren der resultierenden Matrix aus Puffer C auf einen Host. Die API-C-Definition wird gezeigt, mit einer Erläuterung der fünf Argumente zum Erstellen eines Puffers, einschließlich Kontext, Flags, Größe, Hostzeiger und Rückgabewert. Anschließend erklärt der Referent den dritten wichtigen Schritt im OpenCL-Programm, die Kernel-Kompilierung, anhand eines einfachen Kompilierungsprozesses für FPGA-Geräte. Der Prozess umfasst das Erstellen und Erstellen eines Programms und das Auswählen der richtigen Kernelfunktion aus dem Quellcode. Abschließend erläutert der Redner, wie Kernel-Argumente initialisiert werden, bevor das Kernel-Programm ausgeführt wird, indem die OpenCL-API für Kernel-Argumente von CL festgelegt wird.
  
  
• 00:35:00 In diesem Abschnitt erläutert der Referent den Prozess der Initialisierung von Kernel-Argumenten, des Festlegens von Arbeitsgruppengrößen, des Ausführens des Kernels und des Erhaltens von Ergebnissen in einem OpenCL-Programm. Der Benutzer muss die API „CL create kernel“ verwenden und die Größe und den Wert des Kernelarguments angeben, indem er einen Zeiger auf den tatsächlichen Wert verwendet. Der Referent betont, wie wichtig es ist, Argumentindizes korrekt zu setzen und beim Kopieren und Einfügen für jede Zeile zu modifizieren. Die lokalen und globalen Arbeitsgruppengrößen müssen für die Anzahl der Arbeitselemente und Arbeitsgruppen festgelegt werden. Schließlich wird der verbundene CL-Puffer verwendet, um den Ausgangspuffer im Speicher des Hosts zu lesen, was die Synchronisierungsanforderungen für eine ordnungsgemäße Ausführung anzeigt.
  
  
• 00:40:00 In diesem Abschnitt stellt der Referent ein Beispiel für die Matrixmultiplikation mit OpenCL vor. Der Quellcode für das Beispiel der Matrixmultiplikation besteht aus mehreren Dateien, darunter das hostseitige Programm, das Kernelprogramm und ein Makefile, das beim Kompilieren des Projekts hilft. Das hostseitige Programm ist in C geschrieben und enthält Standardbibliotheken und spezifische Header-Dateien für das OpenCL-Framework. Das Beispiel enthält Eingabematrizen und Deklarationen für Variablen, einschließlich der Anzahl der Plattformen und Geräte, des Kontexts, des OpenCL-Programms und des OpenCL-Kernels. Der Referent erklärt auch, wie man den Kernel-Quellcode kompiliert und beschreibt die Größen der Eingabematrizen und der resultierenden Ausgabematrix.
  
  
• 00:45:00 In diesem Abschnitt des Videos demonstriert der Moderator, wie man Geräte- und Plattform-IDs für OpenCL auf einem Mac OS erhält. Durch den Aufruf verschiedener OpenCL-Funktionen wie Get Platform ID und das Erstellen von Befehlswarteschlangen erstellt der Sprecher einen OpenCL-Kontext und kompiliert das Programm. Sie erklären auch, dass der gezeigte Code sowohl Mac OS als auch ein OpenCL SDK unterstützt und einen Fehler meldet, wenn er auf einer anderen Plattform ausgeführt wird.
  
  
• 00:50:00 In diesem Abschnitt zeigt das Video, wie ein Programmobjekt mit OpenCL auf verschiedenen Plattformen erstellt wird. Auf Mac OS wird das Programmobjekt aus einer Kernel-Quellcodedatei erstellt, während es auf dem Altera FPGA OpenCL SDK aus einer durch Kompilierung generierten Binärdatei erstellt wird. Sobald das Programmobjekt erstellt ist, kann das Kernprogramm erstellt werden und die spezifische Kernfunktion kann aus diesem Programmobjekt ausgewählt werden. Am Ende dieses Abschnitts sind die notwendigen Objekte und Funktionen für den nächsten Abschnitt des Programms bereit.
  
  
• 00:55:00 In diesem Abschnitt erläutert das Video den Pufferverwaltungsprozess, einschließlich der Zuweisung eines Puffers zum Speichern der Matrixergebnisse und der Verwendung von CL create buffer zum Erstellen von Puffern auf der Geräteseite. Das Video zeigt auch, wie wichtig es ist, den Rückgabewert des CL in Q und den Range Colonel zu überprüfen, um eine erfolgreiche Ausführung sicherzustellen, insbesondere bei der Verwendung von FPGAs. Darüber hinaus erklärt das Video den Prozess der Überprüfung der Ergebnisse durch Ausdruck der auf der Hostseite zugewiesenen Ressourcen und der verwendeten OpenCL-Ressourcen und bietet ein einfaches Multiplikations-Kernel-Beispiel, in dem sieben Argumente verwendet werden, um Punktproduktoperationen durch Iterationen durchzuführen.
  
  
• 01:00:00 In diesem Abschnitt des Videos erläutert der Referent zwei Beispiele für die Verwendung von OpenCL. Die erste ist die Matrixmultiplikation. Das Programm verarbeitet zwei Matrizen und multipliziert ihre entsprechenden Elemente, um das Ergebnis in einer dritten Matrix zu speichern. Das zweite Beispiel ist die Bilddrehung, bei der das Programm die Pixel eines Bildes nach bestimmten Formeln dreht. Diese Formeln berücksichtigen die ursprünglichen und neuen Koordinaten jedes Pixels und den Rotationswinkel.
  
  
• 01:05:00 In diesem Abschnitt erläutert der Referent, wie ein Bildrotationsproblem mithilfe der Eingabezerlegung in kleinere Probleme zerlegt werden kann. Sie erklären, dass die Pixelinformationen des Bildes durch unabhängige Berechnungen der x- und y-Dimensionen an eine neue Position kopiert werden. Arbeitsgruppen werden zugewiesen, um die neue Position jedes Pixels unter Verwendung seiner globalen ID zu berechnen. Der Referent erläutert auch, wie Arbeitselementgruppen und -dimensionen bestimmt werden, sowie die Kernelfunktion, die zum Abschließen dieses Vorgangs erforderlich ist. Ziel ist es, eine effizientere und skalierbarere Methode zur Berechnung der Bildrotation zu schaffen.
  
  
• 01:10:00 In diesem Abschnitt erklärt der Videomoderator, wie man mit OpenCL ein Bild dreht. Die Kernel-Funktion wird verwendet, um die ursprüngliche Position eines Pixels zu identifizieren, die neue Position des Pixels mithilfe von Rotationsparametern zu berechnen, auf Grenzüberprüfung zu prüfen, um sicherzustellen, dass die neuen Koordinaten in die ursprüngliche Bildgröße fallen, und die Pixelinformationen von der ursprünglichen Position zu kopieren zum neuen Standort. Der Code enthält auch C++-Bindungen für die OpenCL-API und Schritte zum Abfragen von Plattformen, zum Erfassen von Geräten und zum Deklarieren von Puffern, um Daten aus dem Hostspeicher in den Gerätepuffer zu verschieben. Der Nur-Lese-Puffer wird auch erstellt, um die Sicherheit der Originaldaten zu gewährleisten.
  
  
• 01:15:00 In diesem Abschnitt erläutert der Referent die Schritte, die erforderlich sind, um eine Bilddrehung mit OpenCL durchzuführen. Zuerst muss das Originalbild in einen Bildpuffer kopiert werden. Dann wird der Kernel kompiliert und ausgeführt, indem der Zielpuffer initialisiert und die richtigen Kernelargumente gesetzt werden, einschließlich der Abmessungen des Originalbilds und der Rotationsparameter. Der Kernel wird mit der globalen Arbeitsgruppengröße und der lokalen Arbeitsgruppengröße ausgeführt. Schließlich wird das Ergebnis unter Verwendung des in Q-Lesepuffers an den Host zurückgelesen. Der Referent demonstriert auch den beispielhaften Quellcode für die Bildrotation, der Header-Dateien, Hilfsfunktionen, Plattform- und Geräte-IDs, Befehlswarteschlangen, Programm- und Kernel-Objekte sowie Eingabe-/Ausgabepuffer für die ursprünglichen und gedrehten Bilder enthält.
  
  
• 01:20:00 In diesem Abschnitt behandelt das Video den Prozess des Drehens eines Bildes mit OpenCL. Der Host liest das Bild im BMP-Format und wandelt es in ein Array von Gleitkommazahlen um, die im Eingangsbildpuffer gespeichert sind. Der Ausgabepuffer auf dem Host wird erstellt und mit Zufallszahlen initialisiert. Die Plattform wird abgefragt, um die Geräte auf der Plattform zu finden und eine Kontext- und Befehlswarteschlange zu erstellen. Die Programm- und Kernel-Objekte werden erstellt, und geräteseitige Puffer werden erstellt, um das ursprüngliche und gedrehte Bild zu speichern. Das Original-Image wird auf der Geräteseite in den Puffer kopiert, und die Kernel-Argumente werden gesetzt. Der Kernel wird ausgeführt, indem er mit den globalen und lokalen Arbeitsgruppengrößen instanziiert wird. Der Rückgabewert wird überprüft, um sicherzustellen, dass der Kernel erfolgreich ausgeführt wurde.
  
  
• 01:25:00 In diesem Abschnitt gibt der Referent einen Überblick über die Bildrotation mit OpenCL. Nach Abschluss des Kernels werden die Ausgangsdaten unter Verwendung des Zeigers auf den globalen Speicher auf der Geräteseite zum Host zurückgelesen, und ein Host-Puffer wird zum Speichern des Bildes bereitgestellt. Die BMP-Formatierung ist an dem Prozess beteiligt, und eine Hilfsfunktion namens Write BMP Float wird zum Erstellen einer neuen BMP-Datei verwendet, die das Ergebnis anzeigt. Die Kernfunktion wird detailliert beschrieben, wobei die Ziel- und Quellpufferzeiger zusammen mit den Bildabmessungen und Rotationsparametern weitergegeben werden. Die Formel zum Berechnen neuer Koordinaten jedes Pixels wird verwendet, und eine Grenzprüfung wird angewendet, bevor die Pixelinformationen von der ursprünglichen Position an die neue Position kopiert werden. Der Prozess wird anhand eines Beispiels demonstriert, bei dem ein Katzenbild um 45 Grad gedreht wird.
  
  
• 01:30:00 In diesem Abschnitt erläutert der Referent das Konzept der Bildfilterung mit OpenCL. Er beschreibt den Prozess der Verwendung eines 3x3-Filters zum Multiplizieren und Summieren der Werte benachbarter Pixel, um den neuen gefilterten Pixelwert zu erhalten. Er betont auch die Notwendigkeit, beim Umgang mit Pixeln in der Nähe der Grenze, die weniger benachbarte Pixel zum Anwenden des Filters haben, vorsichtig zu sein. Der Referent demonstriert dann verschiedene Arten von Bildfiltern, die mit OpenCL auf ein Originalbild angewendet werden können. Anschließend präsentiert er eine Beispielimplementierung der Bildfaltungsfunktion mit zwei verschachtelten for-Schleifen, die alle Pixel im Bild durchlaufen, und einer dritten Schleife, die die Elemente im Filter durchläuft.
  
  
• 01:35:00 In diesem Abschnitt spricht der Sprecher über die Bilddatenstruktur in OpenGL, bei der es sich um einen undurchsichtigen Typ handelt, der als mehrdimensionale Struktur beibehalten und für Bilddatentypen verwendet wird. Im Gegensatz zu Ganzzahl- oder Zeigertypen können Bilder nicht direkt durch Punkte in einem Gerät betrachtet werden, und ihre Pixelwerte können als Float- oder Ganzzahlwerte angegeben werden. Das Erstellen von Bildobjekten auf der Geräteseite ermöglicht es den OpenCL-Recheneinheiten, neue Pixel in die Bildobjekte zu lesen und zu schreiben, und es ist vorteilhaft für lange, optimierte Befehlssequenzen, die für die Bilddatenverarbeitung oder Grafikprozessoren spezifisch sind. Der Referent erklärt auch, wie ein Quellbildpuffer, ein Ausgabebildobjekt und ein Filter erstellt werden, indem Bild- und Filterdaten mithilfe von APIs wie CL Write Image und CL Create Buffer auf das Gerät kopiert werden.
  
  
• 01:40:00 In diesem Abschnitt stellt der Moderator das Konzept des OpenCL-Samplers vor, bei dem es sich um ein Objekt handelt, mit dem beschrieben wird, wie auf ein Bild zugegriffen wird. Der Sampler wird mithilfe der API-Funktion erstellt, die den Kontext als Argument verwendet und definiert, ob die Koordinaten normalisiert werden oder nicht. Der Adressierungsmodus wird ebenfalls definiert, der behandelt, wie die Bildkoordinaten behandelt werden, wenn sie außerhalb des Bereichs liegen. Der Filtermodus gibt den Filter an, der angewendet werden muss, wenn die Koordinaten zwischen die Pixel fallen. Außerdem wird eine Kernel-Funktion namens Convolution eingeführt, die 2D-Bildobjekte als Eingabe und Ausgabe, einen konstanten Float-Filter zum Speichern von Filterwerten und das Sampler-Objekt verwendet. Die Kernfunktion liest Datenelemente aus dem Bildobjekt und gibt einen Vektor aus vier Gleitkommazahlen zurück, um Arithmetik an Bilddaten durchzuführen.
  
  
• 01:45:00 In diesem Abschnitt erklärt der Referent, wie Operationen mit Gleitkommavektoren unter Verwendung eines Gleitkommavektors mit vier Elementen durchgeführt werden. Sie durchlaufen den Prozess der Initialisierung des Filterindex, der Deklaration von Variablen für Zwei-Element-Koordinaten, der Iteration durch Filterzeilen und der Berechnung von Koordinaten in zwei Dimensionen. Das Pixel wird unter Verwendung der Bildlese-F-Funktion aus dem Bildobjekt gelesen und mit dem Filterpixelwert multipliziert, wobei der aktualisierte Wert im Ausgangsbild gespeichert wird. Zuletzt wird das Bild unter Verwendung einer CL-Tintenlesebildfunktion zurückgelesen.
  
  
• 01:50:00 In diesem Abschnitt wird der Code für OpenCL-Beispiele (I) besprochen, der Filter für die Verwendung in der Bildverarbeitung bereitstellt. Das Programm weist jedem Filtertyp unterschiedliche Größen und Werte zu und verwendet Hilfsfunktionen, um Filterwerte zu initialisieren und BMP-Bilddaten aus einer Datei zu lesen. Die Plattform- und Geräteerkennung wird durchgeführt, bevor die Eingabe- und Ausgabeabbilder sowie der Filterpuffer erstellt werden. Nach der Initialisierung richtet der Sampler ein, wie Pixel, die aus der Grenze fallen, verarbeitet werden, bevor der Kernel mit den entsprechenden Filterparametern ausgeführt wird. Die globale Größe wird auf die Anzahl der Spalten und Zeilen im Bild festgelegt.
  
  
• 01:55:00 In diesem Abschnitt demonstriert der Sprecher ein Beispiel für die Verwendung von OpenCL, um einen Faltungsfilter auf ein Bild anzuwenden. Der Prozess umfasst das Einrichten eines Kernels, der das gesamte Bild verarbeitet und eine lokale Größe von 8 mal 8 Arbeitselementen in einer Gruppe in einer Datendimension verwendet. Das Ausgangsabbild wird auf der Geräteseite gespeichert und kann mit CL read image an den Host zurückgelesen werden. Die Ergebnisse werden dann mit einem gefilterten Referenzbild verglichen, das durch Ausführen des Filters auf der Hostseite erzeugt wurde. Die beiden Bilder sind visuell identisch, was die Ergebnisse bestätigt. Schließlich werden die Ressourcen sowohl auf der Host- als auch auf der Geräteseite freigegeben.

[MetaQuotes]

Ein Vergleich von SYCL, OpenCL, CUDA und OpenMP für die massiv parallele Support-Vektor-Klassifizierung ( WOCL / SYCLcon 2022 )

Ein Vergleich von SYCL, OpenCL, CUDA und OpenMP für die Massively Parallel Support Vector-Klassifizierung

Das Video vergleicht die Leistung von SYCL, OpenCL, CUDA und OpenMP auf verschiedenen Hardwareplattformen für die massiv parallele Support Vector Machine-Klassifizierung. Der Referent erklärt die Parallelisierung der Matrix-Vektor-Multiplikation mit einer Implementierung namens Parallel Fibonacci, die Multigpu-Ausführung unterstützt, aber nur binäre Klassifikation und dichte Berechnungen. Die zum Testen verwendete Hardware umfasst Nvidia A100 und RTX 380 GPUs, AMD Radeon Pro 7 GPU und Intel Core E9-10-09020X CPU. Die Ergebnisse zeigen, dass CUDA das schnellste Backend für Nvidia-GPUs ist, während OpenCL das schnellste Backend für CPUs ist. SYCL ist benutzerfreundlich, während Hipsicle schneller als DPC++ und OpenCL für eine kostengünstige Nutzung ist. Darüber hinaus erörtert der Redner zukünftige Arbeiten, wie z. B. die Untersuchung der Leistung von FPGAs, das Hinzufügen von Unterstützung für verteilte Systeme über MPIs und die Verwendung gemischter Präzisionsberechnungen und spezieller Hardware für maschinelles Lernen wie die Tensorkerne von NVIDIA.

• 00:00:00 In diesem Abschnitt des Videos stellt der Sprecher einen Vergleich verschiedener paralleler Programmiersprachen vor, darunter SYCL, OpenCL, CUDA und OpenMP, mit Schwerpunkt auf deren Verwendung für die Klassifizierung von Massively Parallel Support Vector Machine (SVM). Hardware von mehreren Anbietern. Der Referent stellt die Support Vector Machine vor und skizziert deren Einsatz beim überwachten maschinellen Lernen für die binäre Klassifikation. Herkömmliche Support-Vektor-Maschinen haben jedoch ein Problem darin, dass sie ein konvexes quadratisches Programmierproblem auf sequentielle Weise lösen. Um dieses Problem zu lösen, verwendet der Sprecher die Formulierung der Unterstützungsvektormaschine der kleinsten Quadrate, wodurch das Problem auf das Lösen eines Systems linearer Gleichungen reduziert wird. Der Referent diskutiert auch die Implementierungsdetails ihrer Bibliothek, die Parallel Fibonacci genannt wird.
  
  
• 00:05:00 In diesem Abschnitt erklärt der Referent die PLSS-VM, die in modernem C++ geschrieben ist. Mit einem einzigen Vorlagenparameter ist es möglich, zwischen Fließkommatypen mit einfacher und doppelter Genauigkeit umzuschalten. Der Referent spricht auch über die Parallelisierung der Matrix-Vektor-Multiplikation im CG-Algorithmus, da dies der rechenintensivste Teil des Algorithmus ist. Sie implementierten vier verschiedene Backends (OpenMP, CUDA, OpenCL, Signal) und unterstützten die Multigpu-Ausführung. Derzeit werden jedoch nur binäre Klassifizierung und dichte Berechnungen unterstützt, und sie unterstützen keine standardmäßige Multiclass-Klassifizierung. Darüber hinaus weicht das OpenMP-Backend stark von anderen Implementierungen ab, und für die GPU-Backends (CUDA, OpenCL und SYCL) wurde ein CG implementiert und für alle drei Backends verwendet, um Codeduplizierung und potenzielle Fehler zu reduzieren.
  
  
• 00:10:00 In diesem Abschnitt des Videos werden die verwendete Hardware und die Methodik für die Tests erklärt. Der Fokus liegt auf vier verschiedenen Plattformen, nämlich den GPUs Nvidia A100 und RTX 380, der GPU AMD Radeon Pro 7 und der CPU Intel Core E9-10-09020X, und die Ergebnisse für diese werden diskutiert. Die N-Punkt-Skalierung für die Nvidia A100- und RTX 380-GPUs sowie die Datenpunkt- und Feature-Skalierung für die AMD Radeon Pro 7-GPU wurden untersucht, und es wurde festgestellt, dass die Laufzeiten mit der Anzahl der Datenpunkte auf beiden NVIDIA in ähnlicher Weise steigen GPUs. Unter diesen erweist sich Cuda als das schnellste Backend, gefolgt von OpenCL, und das mit N-Site-Computing generierte Roofline-Modell zeigte, dass die hierarchischen Kernel-Formulierungen tendenziell speichergebundener sind als ihre Gegenstücke im ND-Bereich. Insgesamt sind die Laufzeiten bei AMD höher als bei NVIDIA.
  
  
• 00:15:00 In diesem Abschnitt behandelt das Video den Leistungsvergleich von SYCL, OpenCL, CUDA und OpenMP auf verschiedenen Hardwareplattformen. Die Nvidia-GPUs zeigten keine Laufzeiterhöhung und das schnellste Backend war OpenCL. Die AMD-GPU hatte jedoch eine schlechtere Leistung als erwartet, was möglicherweise darauf zurückzuführen ist, dass die Blockgrößen nicht fein abgestimmt wurden. Die Intel Core E9-CPU verhielt sich ähnlich wie die Nvidia-GPUs, wobei OpenCL das schnellste Backend war. DPC++ war am schnellsten, außer bei kleinen Datensätzen, bei denen OpenMP schneller war. Die hierarchische DPC++-Kernelformulierung war auf allen Hardwareplattformen langsamer als ihr Gegenstück im Indie-Bereich, was auf Optimierungspotenzial hinweist. Schließlich war der Overhead der OpenCL-Cheat-Kompilierung auf Nvidia-GPUs am schnellsten und auf der Intel Iris Xe Max-GPU am langsamsten, aber mit integriertem Caching kann der Overhead in nachfolgenden Ausführungen reduziert werden.
  
  
• 00:20:00 In diesem Abschnitt des Transkripts erörtert der Moderator die Ergebnisse seiner Tests mit verschiedenen parallelen Programmiersprachen und Frameworks für die Ausrichtung auf Hardware von verschiedenen Anbietern wie NVIDIA, AMD und Intel. Sie stellen fest, dass CUDA immer noch die beste Option ist, wenn Sie nur auf NVIDIA-GPUs abzielen müssen, da es in ihren Tests die schnellste Leistung hatte. OpenMP ist ein guter Anfang, wenn es nur auf CPUs abzielt, obwohl es in ihren Tests nicht die beste Leistung hatte. Wenn Sie auf Hardware anderer Anbieter abzielen müssen, wird OpenCL oder SYCL empfohlen, obwohl SYCL besser ist, wenn Sie einen neuen Algorithmus von Grund auf neu implementieren, da es benutzerfreundlicher ist. Hipsicle ist die beste Option für eine kostengünstige Nutzung und schneller als DPC++ und OpenCL auf GPUs, und sie planen, ihr OpenMP-Backend zu optimieren und in Zukunft andere Signalimplementierungen wie ComputeCPP zu untersuchen.
  
  
• 00:25:00 In diesem Abschnitt schließt der Sprecher das Video ab, indem er zukünftige Arbeiten und Verbesserungen an der Implementierung der Support-Vektor-Klassifizierung unter Verwendung verschiedener Parallel-Computing-Frameworks diskutiert. Sie planen, die Leistung auf unterschiedlicher Hardware wie FPGAs zu untersuchen, Unterstützung für verteilte Systeme über MPIs hinzuzufügen und die Auswirkungen der Verwendung gemischter Präzisionsberechnungen und spezieller Hardware für maschinelles Lernen wie NVIDIAs Tensorkerne zu untersuchen. Sie glauben, dass diese Verbesserungen die Geschwindigkeit und Effizienz ihrer Implementierung bei größeren Datensätzen erhöhen werden.

[MetaQuotes]

Erreichen von noch reichhaltigerem C++ in OpenCL-Kerneln mit der Verwendung von libclcxx ( WOCL / SYCLcon 2022 )

Erreichen von noch reichhaltigerem C++ in OpenCL-Kernels mit der Verwendung von libclcxx

Das Video behandelt die Verwendung von libclcxx, um die Integration von C++-Bibliotheken in die Open-Source-Kernel-Entwicklung zu ermöglichen. Das Projekt integriert Type Traits, eine wesentliche Bibliothek für die Metaprogrammierung in C++, mit dem Ziel, Entwicklern mehr C++-Funktionalität zur Verfügung zu stellen. Das Video zeigt, wie die Type-Traits-Bibliothek die Leistung von OpenCL-Kernels durch ihre Fähigkeit, Adressraum und Vektortypen zu manipulieren, optimieren kann. Das Video ermutigt Entwickler, mit der Bibliothek zu experimentieren und zur Verkürzung der Entwicklungszyklen beizutragen, während gleichzeitig maximale Kompatibilität mit C++ erreicht wird. Die Bibliothek bietet Oxygen-Dokumentation in einem ähnlichen Stil wie die C++-Referenzseiten, was es Entwicklern erleichtert, durch die neue Funktionalität zu navigieren.

• 00:00:00 In diesem Abschnitt erörtert Stulova von Anastasia die Verwendung von lipclcxx, um die Verwendung von C++-Bibliotheken in der Open-Source-Kernel-Entwicklung zu ermöglichen. Obwohl C++ für die OpenCL-Kernelsprache über C++-Fähigkeiten verfügt, fehlt es ihr an Bibliotheksunterstützung, weshalb es wichtig ist, die dargestellte Einschränkung anzugehen. Als Ergebnis wurde das Leap clcxx-Projekt erstellt, das lipcxcxx integriert, mit dem Ziel, Open-Source-Kernel-Entwicklern mehr C++-Funktionalität zur Verfügung zu stellen. Darüber hinaus argumentiert Tulva, dass Typetraits eine wesentliche Bibliothek sind, um die vollständige Metaprogrammierung in C++ zu erleichtern, und erweitert den Namensraum std, um Spezialisierungen für vorhandene Merkmale bereitzustellen, während neue Merkmale unter anderem für den Vektortyp offener Zellen hinzugefügt werden. Die neue Bibliothek bietet Oxygen-Dokumentation in einem ähnlichen Stil wie die C++-Referenzseiten, was es Entwicklern erleichtert, durch die neue Funktionalität zu navigieren.
  
  
• 00:05:00 In diesem Abschnitt erläutert das Video, wie die Verwendung der Type-Trait-Bibliothek die Leistung von OpenCL-Kernels verbessern kann, insbesondere in Bezug auf Adressraum und Vektorhandel. Das Video zeigt Beispiele, die zeigen, wie die Bibliothek verwendet werden kann, um eine Vorlagenfunktion für verschiedene Zeigertypen zu erstellen, und wie das Entfernen des Adressraums aus dem Typ Probleme in der OpenCL-Umgebung lösen kann. Darüber hinaus zeigt das Video, wie die Einbeziehung von Vektorgrößen-Trades Berechnungen effizienter machen kann, und hebt hervor, wie die Implementierung von Reduktionsalgorithmen für Vektortypen angepasst werden kann. Insgesamt kann die Verwendung von Type Trades in OpenCL-Kerneln zu einer noch reichhaltigeren C++-Programmierung führen.
  
  
• 00:10:00 In diesem Abschnitt erklärt der Referent, wie die Funktion zum Hinzufügen von Alarmen in OpenCL-Kernels mithilfe der Vektorgröße als Bedingung definiert wird. Sie verdeutlichen, dass für unterschiedliche Vektorgrößen eine andere Implementierung gewählt wird und dass, wenn der übergebene Typ kein Vektortyp ist, ein Element aus dem Puffer zurückgegeben wird. Der Referent lädt auch Entwickler ein, zu experimentieren und Beiträge zu leisten und die maximale Kompatibilität mit C++ zu erreichen, um Entwicklungszyklen zu verkürzen. Sie bitten um Feedback zu fehlenden Funktionen oder Fehlern und ermutigen zur Teilnahme an einer Diskussion zu einem bestehenden Problem auf der Projektseite.

[MetaQuotes]

SYCL über OpenCL hinaus: Die Architektur, der aktuelle Stand und die zukünftige Ausrichtung von hipSYCL ( IWOCL / SYCLcon 2020 )

SYCL über OpenCL hinaus: Die Architektur, der aktuelle Stand und die zukünftige Ausrichtung von hipSYCL

Das hipSYCL-Projekt ist eine Open-Source-Implementierung von SYCL, die GPUs über das HIP-Programmiermodell anstelle von OpenCL anspricht. Es besteht aus einer Compiler-Komponente, einer Sichel-Schnittstelle und einer sicheren Laufzeit. Der sichere Compiler identifiziert Kernel, handhabt die lokale Speicherzuweisung und implementiert einen Signalisierungsmechanismus. Die Dispatch-Funktion erstellt spezifische Artikel basierend auf vom Benutzer bereitgestellten Kerneln, und optimierte Funktionen können mit Rock Prim definiert werden. Die zukünftige Richtung besteht darin, mehrere Back-Ends zuzulassen und Einschränkungen des statischen Kompilierungsmodells aufzuheben. Das Operations-Übermittlungsmodell wird für einen höheren Aufgabendurchsatz auf eine Batch-Übermittlung umgestellt, und hipSYCL ist auf Quellcodeebene interoperabel, was das Mischen und Abgleichen mit hip und CUDA ermöglicht. Als Open-Source-Projekt sind Mitwirkende willkommen.

• 00:00:00 In diesem Abschnitt erörtert der Redner die Motivation hinter dem hipSYCL-Projekt, einer Open-Source-SYCL-Implementierung, die direkt auf GPUs durch das HIP-Programmiermodell abzielt, anstatt OpenCL zu verwenden. Ziel ist es, den Code zu optimieren und die Verwendung von vom Anbieter bereitgestellten Profilern und Debuggern zu vereinfachen und gleichzeitig die Akzeptanzprobleme zu vermeiden, die bei anderen Programmiermodellen auftreten können. Der Referent vergleicht hipSYCL auch mit anderen Lösungen, die für SYCL- und CUDA-Interoperabilität verfügbar sind, und platziert hipSYCL aufgrund seiner Verwendung des HIP-Programmiermodells am Ende der CUDA-Interoperabilitätsskala.
  
  
• 00:05:00 In diesem Abschnitt erklärt das Video die Funktionsweise von hipSYCL und seine drei Hauptkomponenten: eine Compiler-Komponente, eine Sichel-Schnittstelle und eine sichere Laufzeit. Die Compiler-Komponente ermöglicht es dem Compiler, sowohl CUDA als auch Sichel zu verstehen, was Interoperabilität auf Quellcodeebene ermöglicht. Die sichere Laufzeit kümmert sich um die Datenverwaltung und das Planen von Aufgaben, während die Sichel-Schnittstelle aus Klassen und Funktionen im Sichel-Namensraum besteht. Darüber hinaus erwähnt das Video, dass Sichel eine flexible Lösung ist, mit der Implementierungen erstellt werden können, die alle möglichen Anwendungsfälle abdecken. Um auf Beschleuniger abzuzielen, wird eine dedizierte Compiler-Komponente benötigt, die Kernel identifiziert und für den Beschleuniger kompiliert.
  
  
• 00:10:00 In diesem Abschnitt des Videos erläutert der Referent, wie der sichere Compiler in hipSYCL funktioniert. Sie erklären, dass der Compiler die Kernel identifizieren und bestimmen muss, welcher Code an das Gerät ausgegeben werden muss, und dann behandeln muss, wie die Kernel im lokalen Speicher zugewiesen werden. Auch die sichelspezifische Diagnosefunktion wird als Priorität für die zukünftige Entwicklung genannt. Der Referent erklärt, dass die Verwendung der hip-sicheren Compiler-Komponente relativ einfach ist, da ein Compiler-Wrapper namens Cycle CC verwendet wird, der die damit verbundene Komplexität verbirgt, wie das korrekte Aufrufen und Verlinken des Compilers, und wie man Include-Pfade setzt. Sie diskutieren, wie das Aufrufen von Kernels ein wenig Trickserei erfordert, und erklären, wie es gemacht wird. Zusätzlich wird in hipSYCL für dynamische Out-of-Order-Verarbeitung ein Signalisierungsmechanismus verwendet, der derzeit Coroutinen und Hip-Ereignisse verwendet, aber die Kehrseite davon wird diskutiert.
  
  
• 00:15:00 In diesem Abschnitt erläutert der Redner, wie die Dispatch-Funktion verwendet wird, um ein bestimmtes Element basierend auf dem vom Benutzer bereitgestellten Kernel zu erstellen, und wie die Parallele für und sicher implementiert werden kann, indem die Dispatch-Funktion mit dem vom Benutzer bereitgestellten Kernel instanziiert wird Kernel. Zunächst wird jedoch der gesamte Code als Hostcode übergeben, wobei der vom Benutzer bereitgestellte Kernel ein Host-Lambda ist und nicht direkt aufgerufen werden kann, sodass ein Dummy-Attribut namens HIP-Kernel hinzugefügt wird, das nur durch einen ordnungsgemäßen Klick auf ersetzt wird das Attribut, sobald das anfängliche Parsing abgeschlossen ist und das hipSYCL-Plug-in übernommen hat. Sie erreichen sowohl für hipSYCL als auch für CUDA eine gute Speicherleistung, und mit hipSYCL können sie die Interoperabilität von Hip und CUDA auf Quellcodeebene erreichen.
  
  
• 00:20:00 In diesem Abschnitt erläutert der Referent, wie eine optimierte Reduktion mithilfe von Rock Prim mit Epsilon implementiert wird. Sie schlagen vor, eine optimierte Funktion mit der sicheren Makro-Zip-Plattform cuda oder hips a good platform rockem zu definieren, die als Host und Gerät gekennzeichnet ist. Beim Kompilieren für die Zielplattform wird die optimierte Funktion aufgerufen, während andernfalls eine Fallback-Funktion aufgerufen wird. Der Referent erklärt, dass herstelleroptimierte Bibliotheken wie Rock Prim eine schnellere Leistung erzielen, weil sie mehr Wissen über die Zielhardware haben, und obwohl hipSYCL immer noch vorkonform ist und einige Funktionen wie Bilder und Open-State-Interoperabilität fehlen, ist es immer noch real nutzbar -Weltanwendungen. Ein arrangierter paralleler Fall auf dem CPU-Paket ist jedoch aufgrund eines Problems mit reinen Bibliothekszyklusimplementierungen langsam.
  
  
• 00:25:00 In diesem Abschnitt erörtert der Redner die Leistungsunterschiede bei der Verwendung der grundlegenden parallelen Form oder der hierarchischen parallelen Form gegenüber der Verwendung der parallelen Form des nd-Bereichs mit hipSYCL auf einer CPU. Letzteres führt zu einem massiven Leistungsverlust, da so viele Bedrohungen gestartet werden müssen, wie Arbeitselemente in jeder Arbeitsgruppe vorhanden sind. Anschließend spricht der Referent über die zukünftige Ausrichtung von hipSYCL, nämlich eine neue Runtime zu schaffen, die es erlaubt, dass beliebige Backends gleichzeitig aktiv sind, und Einschränkungen bezüglich des statischen Kompilierungsmodells aufhebt. Sie wechseln auch zu einer End-to-End-Zuordnung, bei der n zyklische Verwendungen M Back-End-Warteschlangen zugeordnet werden, um die Hardwarenutzung zu optimieren. Darüber hinaus wird es eine strikte Trennung zwischen der neuen Laufzeit und der bestehenden SYCL-Schnittstelle geben, um die Wartung und das Experimentieren zu erleichtern.
  
  
• 00:30:00 In diesem Abschnitt erörtert der Referent die Verbesserungen, die am Operation Submission Model in hipSYCL vorgenommen werden. Sie wechseln von einem signalbasierten Übermittlungsmodell zu einem Stapelübermittlungsmodell, bei dem die Signalisierung an die Laufzeit, dass die Dinge abgeschlossen sind, nur einmal pro Stapel von Vorgängen erfolgt, was einen höheren Aufgabendurchsatz ermöglicht. Der Referent erläutert den Prozess, in dem die Arbeitsgänge eingereicht und dann vom Decksbauer bearbeitet, gesammelt und bestellt werden. Der Deck-Scheduler weist dann den Operationen Ausführungshinweise zu, die dann an die Backend-Executoren gehen, um den Kernel auszuführen und zu bestimmen, welche Synchronisationsoperationen notwendig sind. Die Kostenschätzung dieser Konfiguration geht dann zurück an den Deck-Scheduler, um die Operationen weiter zu optimieren oder so zu übermitteln, wie sie sind. Der Referent gibt auch Informationen darüber, wie man hipSYCL über seine Paket-Repositories und Installationsskripte erhält.
  
  
• 00:35:00 In diesem Abschnitt wird erklärt, dass hipSYCL eine Implementierung von SICL für CPUs, Video-GPUs und AMD-GPUs ist. Es baut auf den Low-Level-Vendor-APIs hip und CUDA auf, wodurch es auf Quellcodeebene interoperabel wird. Auf diese Weise können Entwickler Hip und CUDA kombinieren und anpassen, wodurch es für eine Reihe von HPC- und anderen Anwendungsfällen geeignet ist, die Zugriff auf die neuesten Low-Level-Hardwareoptimierungen oder herstelleroptimierte Bibliotheken erfordern. Darüber hinaus ermöglicht es die Erstellung hochoptimierter Codepfade für bestimmte Hardware, und es wird erwartet, dass die Kernelleistung mit der von regulärem Hip oder CUDA vergleichbar ist. Als Open-Source-Projekt sind Mitwirkende immer willkommen, und Interessierte können auf der GitHub-Seite mehr darüber erfahren.

[MetaQuotes]

SYCL: Die Zukunft ist offen, parallel und heterogen (Core C++ 2022 )

SYCL: Die Zukunft ist offen, parallel und heterogen

In diesem Video über die SYCL-Programmierung betont der Redner die Notwendigkeit, die Abstraktionsebene zu erhöhen, um die Produktivität zu steigern und mehr Entwickler anzuziehen, da komplexe Modelle eine höhere Rechenleistung erfordern, die von Beschleunigersystemen erfüllt wird. Die Bedeutung von Softwareportabilität und OneAPI wird betont, da Geräte damit auf CPUs, GPUs und anderen Geräten arbeiten können. Die Vorteile von SYCL, einem offenen, parallelen und heterogenen Programmiermodell, werden ebenfalls diskutiert, wobei der Referent die zahlreichen Online-Ressourcen und Tools hervorhebt, die zur Optimierung des Codes und zur Verbesserung der Leistung verfügbar sind. Der Redner ermutigt die Zuschauer, oneapi.io und ihren YouTube-Kanal zu besuchen, um Ressourcen und Unterstützung zu erhalten.

• 00:00:00 In diesem Abschnitt erörtert der Redner die Notwendigkeit, die Abstraktionsebene zu erhöhen, um die Produktivität zu steigern und mehr Entwickler anzuziehen. Je komplexer die Modelle werden, desto schneller steigt der Bedarf an Rechenleistung. Der Referent erwähnt die Ninja-Lücke, die sich auf die Schwierigkeit bezieht, untergeordnete Experten wie Assembly- oder Cuda-Entwickler zu finden und einzustellen. Das Erhöhen der Abstraktionsebene führt zu Leistungsverlusten, weshalb KI-Beschleuniger wie GPUs und GAUDI notwendig sind, um den steigenden Bedarf an Rechenleistung zu decken.
  
  
• 00:05:00 In diesem Abschnitt erörtert der Referent die Notwendigkeit von Beschleunigern, um die schnellste Leistung zu erzielen, stellt jedoch fest, dass ein Beschleuniger nicht ausreicht, um den gesamten Anwendungsbereich abzudecken. Es sind heterogene Systeme erforderlich, die CPUs und Beschleuniger wie ASIC-ähnliche Beschleuniger und CPUs kombinieren. Der Redner betont die Bedeutung der Softwareportabilität und der Fähigkeit des Codes, auf jedem Computer oder Gerät unabhängig von der verwendeten Hardware ausgeführt zu werden, ohne dass für jede Plattform oder jedes Betriebssystem neu codiert, neu kompiliert oder neu erstellt werden muss. OneAPI ist ein Bemühen der Branche, Software-Stacks zu rationalisieren, Bibliotheken und Tools zu vereinheitlichen, um eine offene, kostenlose und geräteübergreifende Software-Portabilität zu gewährleisten, was bedeutet, dass Software-Stacks auf CPUs, GPUs und anderen Geräten funktionieren können. OneAPI bietet ein Basis-Toolkit, das alles enthält, was für den Einstieg benötigt wird.
  
  
• 00:10:00 In diesem Abschnitt erörtert der Referent die Leistungsfähigkeit des OneAPI-basierten Toolkits und das Konzept des Data Policy++-Compilers, der entwickelt wurde, um Heterogenität zu C++-Bibliotheken hinzuzufügen. Durch die Verwendung vordefinierter Richtlinien können Sie einfach auf die CPU oder GPU zugreifen, ohne zu viel über Details auf niedrigerer Ebene über OpenCL oder CUDA wissen zu müssen. Der Compiler bietet die Möglichkeit, überall vorhandene Speicher zu steuern und zu trennen, Ausnahmecodes zu verarbeiten und parallele Berechnungen zu erstellen.
  
  
• 00:15:00 In diesem Abschnitt des Videos erklärt der Sprecher, dass drei Dinge erforderlich sind, um über gute heterogene Rechenfähigkeiten zu verfügen. Die erste ist die Fähigkeit, das Gerät zu erkennen und Informationen darüber zu erhalten. Hier zeigt der Lautsprecher einen einfachen Code, der alle mit dem System verbundenen Geräte erkennt und auflistet. Die zweite Anforderung sind Informationen über den Status der Geräte in Echtzeit, die eine Überwachung der Auslastung und Temperatur ermöglichen und Benutzern auch das Umschalten zwischen CPU und GPU ermöglichen. Die dritte Anforderung ist die Fähigkeit, Speicher effizient und nahtlos zwischen dem Gerät und dem Host auszutauschen, was durch zwei Hauptwege in SYCL erreicht wird – Puffer und einheitlicher Diagrammspeicher.
  
  
• 00:20:00 In diesem Abschnitt erläutert der Referent die Vorteile der Verwendung von SYCL, einem offenen, parallelen und heterogenen Programmiermodell. Durch Hinzufügen von SYCL zu C++ kann man Code schreiben, der auf mehreren Geräten ausgeführt werden kann, einschließlich GPUs, CPUs, ARM und FPGAs. Der Redner erwähnt, dass es zahlreiche Online-Ressourcen und Beispiele dafür gibt, wie SYCL mit mehreren Geräten funktioniert. Intel Advisor ist ein vom Referenten empfohlenes Tool, das bei der Optimierung von Code helfen kann und die Möglichkeit bietet, bestimmte Funktionen auf eine GPU auszulagern. Der Referent betont die Bedeutung der Verwendung dieses Tools, das den Code viel schneller ausführen und die Gesamtleistung des Programms verbessern kann.
  
  
• 00:25:00 In diesem Abschnitt wirbt der Redner für die Verwendung von SYCL als schnellste Möglichkeit, Code auf mehreren Geräten von mehreren Anbietern verfügbar zu machen, und ermutigt die Zuschauer, die Website oneapi.io und seinen YouTube-Kanal zu besuchen, um Ressourcen und Unterstützung zu erhalten. Er erwähnt auch die Möglichkeit, dass SYCL in bestimmten Beispielen schneller als CUDA ist, betont jedoch, dass der Hauptvorteil von SYCL seine Portabilität ist, da es die Codierung auf einer einzigen Plattform ermöglicht, die dann auf verschiedenen Geräten ausgeführt werden kann, wodurch die Notwendigkeit entfällt, mehrere zu erstellen Codierungsentscheidungen für verschiedene Geräte. Darüber hinaus bietet der Referent an, alle Fragen zu beantworten und Ressourcen wie Jupyter-Notebooks und Zugriff auf die Intel Devcloud bereitzustellen, um Benutzern den Einstieg in SYCL zu erleichtern.

[MetaQuotes]

GPU-Beschleunigung in Python

GPU-Beschleunigung in Python

Das Video erklärt, wie Sie eine GPU-Beschleunigung in der Python-Programmierung erreichen, indem Sie die Leistung von Grafikprozessoren nutzen, die eine bis zu 10-fache Beschleunigung mit Datenparallelität bieten können. Die beiden Standards für GPU-Computing, OpenCL und CUDA, werden kurz vorgestellt, und das Video demonstriert die Verwendung von Pi OpenCL und CUDA für die Matrixmultiplikation in Python. Der Referent erklärt die Verwendung des globalen Speichers und des Kernels für die Matrixmultiplikation und erörtert auch den Algorithmus, der zum Berechnen eines Elements im Matrix-Matrix-Produkt verwendet wird. Der Code für die GPU-Beschleunigung in C und Python wird besprochen, wobei der Schwerpunkt auf dem Verständnis der internen Darstellungen von Matrizen und der Speicherzuweisung liegt. Die Übungen in der Vorlesung bilden eine Grundlage für die weitere Erforschung des GPU-Computing.

• 00:00:00 In diesem Abschnitt stellt das Video GPU-Computing als Möglichkeit vor, Datenparallelität zu erreichen und Programme zu beschleunigen, indem die Leistung von Grafikprozessoren genutzt wird, die Milliarden von Gleitkommaoperationen pro Sekunde verarbeiten und eine Beschleunigung von a bieten können Faktor 10. Die beiden Standards für GPU-Computing, OpenCL und CUDA, werden kurz vorgestellt, mit Beispielen für High-End-GPUs wie Kepler, Pascal und Volta von Nvidia. Der massiv parallele Aspekt des GPU-Computing wird betont, um die GPU beschäftigt zu halten, wobei häufig die Planung ausreichend vieler Threads erforderlich ist. Das Video erwähnt auch die potenziellen Anwendungen von Hardwarebeschleunigern in wissenschaftlichen und technischen Bereichen.
  
  
• 00:05:00 In diesem Abschnitt des Videos diskutiert der Sprecher die Entwicklung der GPU-Beschleunigung, von Kepler mit einer Spitzenleistung von einem Teraflop bis zur aktuellen Generation mit über 7,9 Teraflops. Das Programmiermodell des Massively Parallel Computing folgt einem Single-Instruction-Multiple-Data-Ansatz, und die Daten werden in Blöcke von Threads unterteilt, und jeder Block führt mindestens einen Thread aus. Der Referent geht auf die Open-Computing-Sprache ein, die ein offener Standard für parallele Programmierung ist und neben GPU-Computing auch Multicore- und Multithread-Computing abdeckt.
  
  
• 00:10:00 In diesem Abschnitt erörtert der Referent die Verwendung von OpenCL und Pi OpenCL für die GPU-Beschleunigung in Python. OpenCL ist ein allgemeiner Standard, der ursprünglich auf NVIDIA-Grafikkarten unterstützt wurde, aber aufgegeben wurde. Es funktioniert jedoch gut auf MacBooks, da es von Apple initiiert wurde. Pi OpenCL vereinfacht die OpenCL-Programmierung, indem es den Boilerplate-Code reduziert und eine einfachere Konzentration auf den Kernel ermöglicht. Es unterstützt auch NumPy-Arrays, aber die Datenstrukturen sind aufgrund der Datenparallelität eingeschränkter. Der Referent demonstriert zu Testzwecken die Verwendung von Pi OpenCL für die Matrixmultiplikation auf zwei ganzzahligen Matrizen.
  
  
• 00:15:00 In diesem Abschnitt erklärt der Referent, wie GPUs für die Matrixmultiplikation in Python mit OpenCL verwendet werden können. Sie beginnen mit dem Import der notwendigen Bibliotheken, einschließlich OpenCL und NumPy. Der Referent weist auch darauf hin, dass die verwendete Grafikkarte keine 64-Bit-Arithmetik unterstützte, weshalb man sich für 32-Bit-Gleitkomma-Arithmetik entschieden habe. Anschließend definieren sie die Matrizen, generieren zufällige Ganzzahlen und ändern ihren Typ in eine 32-Bit-Flussmatrix. Der Sprecher erklärt dann den Boilerplate-Code, der zum Definieren der Gegenstücke von Matrizen auf dem Gerät und zum Erstellen von Warteschlangen erforderlich ist. Abschließend definiert der Referent den Kernel für die Matrixmultiplikation, der beim Ausführen des Programms kompiliert wird, und demonstriert, wie man Matrizen auf der GPU multipliziert.
  
  
• 00:20:00 In diesem Abschnitt erläutert der Referent das Konzept „global“ im Kontext der GPU-Beschleunigung in der Python-Programmierung. Global gibt an, dass sich Matrizen im globalen Speicher der Grafikkarte befinden und jedem Thread Zugriff auf die Daten gewähren. Die Dimensionen werden als Short Integer übergeben, wobei jeder Thread eine eindeutige Identifikationsnummer hat. Der Matrixmultiplikationsprozess profitiert von der GPU-Beschleunigung, da fast jeder Teil unabhängig durch Matrixzeilen- und -spaltenindizierung ausgeführt werden kann. Die Matrizen werden in C-weise als ein langes Array gespeichert, und Zeiger bestimmen ihre Speicherorte.
  
  
• 00:25:00 In diesem Abschnitt erklärt der Sprecher den Algorithmus in C zur Berechnung eines Elements im Matrix-Matrix-Produkt und die potenzielle Beschleunigung der Matrix-Matrix-Multiplikation, die im Allgemeinen eine kubische Operation in den Dimensionen der Matrizen ist. Durch die Verwendung von GPUs und Kernel-Starts kann der Betrieb jedoch auf einen linearen Betrieb vereinfacht werden, was zu einer massiven Kostensenkung und erheblichen Beschleunigungen führt. Der Redner erwähnt auch, dass der einfachste Weg, die Operation durchzuführen, über Python und ohne die Notwendigkeit einer expliziten Kompilierung erfolgt, die tatsächlichen Algorithmen, die in Supercomputern verwendet werden, gemeinsame Speicher auf den GPUs und einen Kompilierungsprozess verwenden, der über das hinausgeht, was in beschrieben wird Video. Der Referent betont die Idee, dass PiCUDA und PiOpenCL es Programmierern ermöglichen, Code auf einer höheren Ebene zu entwickeln, ohne sich um die Kompilierungs- und Verknüpfungsprozesse auf niedrigerer Ebene kümmern zu müssen.
  
  
• 00:30:00 In diesem Abschnitt spricht das Video über die Installation von CUDA für die GPU-Beschleunigung in Python. Um CUDA verwenden zu können, muss ein Benutzer eine NVIDIA-GPU und Treiber installiert haben. Der Vortrag geht durch Anweisungen, um zu überprüfen, ob das System richtig eingerichtet ist, und der Moderator stellt fest, dass es sich bei der Technik um hochinteraktives paralleles Rechnen handelt. Der Dozent erklärt, dass man mit einer guten Grafikkarte auch aus einem High-End-Laptop eine gute Leistung herausholen kann. Der Kurs zeigt dann als Beispiel die Matrizenmultiplikation. Der Moderator merkt an, dass normalerweise ein Programm auf der CPU ausgeführt werden muss und die GPU nur die rechenintensiven Teile beschleunigt. Abschließend diskutiert der Vortrag die Zuweisung von Speicher für entsprechende Matrizen auf der GPU und die Initialisierung der resultierenden Matrizen, wobei festgestellt wird, dass Zuweisungen mit NumPy besser sind als mit C. Außerdem ist zu diesem Zeitpunkt keine Kompilierung erforderlich.
  
  
• 00:35:00 In diesem Abschnitt wird der Code für die GPU-Beschleunigung in C besprochen. Die Matrizen in C werden zeilenweise gespeichert, und der Code nutzt diese Tatsache aus. Die Syntax zum Starten von Blöcken von Threads in einer zweidimensionalen Struktur wird verwendet, um die Threads explizit zu berechnen. Um Zeigerarithmetik zu vermeiden, wird eine Schleife mit expliziter Klammerung verwendet. Die Funktion übernimmt die Dimensionen und Zeiger auf die Daten, zu denen die Matrizen A und B für die Eingabe und die Ergebnismatrix C_gpu gehören. Das Kopieren des Speichers zum Gerät muss vor dem Drucken beendet werden, und das Kopieren des Speichers vom Gerät zum Host muss vor dem Drucken der Daten erfolgen, da das Drucken innerhalb der Funktionen innerhalb der Kernelfunktionen, die von der GPU ausgeführt werden, möglicherweise nicht möglich ist. Schließlich endet die Diskussion mit der Feststellung, dass pyCUDA neuer ist als piOpenCL und PyCUDA.
  
  
• 00:40:00 In diesem Abschnitt erörtert der Redner die GPU-Beschleunigung in Python, das auf CUDA ausgerichtet ist, aber auch Anstrengungen unternimmt, um auf anderen GPUs ausgeführt zu werden. Es kümmert sich sowohl um die Kompilierung als auch um die Ausführung, wodurch nachfolgende Läufe viel schneller werden. Es ist möglich, GPU-Kernel in Python zu entwickeln und dabei in der Skriptumgebung zu bleiben; man muss jedoch verstehen, wie GPUs funktionieren und wie Matrizen intern mit C-Syntax dargestellt werden. Die Übungen in der Vorlesung sind ergebnisoffen und können eine Grundlage für ein zweites Projekt zum Thema GPU-Computing bilden. Insgesamt war dies ein einführender Abschnitt, der eine Vorstellung davon vermitteln sollte, wie Programmierer und Softwareentwickler Funktionen entwickeln können, die auf der GPU laufen.

[MetaQuotes]

OpenCL 3.0 Launch-Präsentation (IWOCL / SYCLcon 2020)

OpenCL 3.0 Launch-Präsentation

Die Einführung von OpenCL 3.0 wird in diesem Video besprochen, wobei der Schwerpunkt auf seiner Bedeutung für die Low-Level-Parallelprogrammierung in der Branche liegt. OpenCL 3.0 fügt der API keine neuen Funktionen hinzu, sondern bietet eine Neuausrichtung des Ökosystems, damit OpenCL mehr Entwickler und Geräte erreichen kann. Der Moderator erörtert auch das Hinzufügen von Erweiterungen für DSP-Light-Prozessoren, die Roadmap für zukünftige Funktionen und das wachsende Ökosystem von Open-Source-Kernelsprachen-Compilern, die Spirit-Kernel für OpenCL Vulcan generieren können. Feedback von Benutzern wird ermutigt, um bei der Fertigstellung der Spezifikation zu helfen, während sich die Arbeitsgruppe auf die erste Implementierungswelle in den nächsten Monaten vorbereitet.

• 00:00:00 In diesem Abschnitt erläutert Neil Travis von NVIDIA und der Khronos-Gruppe die Einführung von OpenCL 3.0 und die Bedeutung des Standards für die Low-Level-Parallelprogrammierung in der Branche. OpenCL wird häufig von GPU-Anbietern und zunehmend von Anwendungen, Engines und Bibliotheken verwendet. Die Einführung von OpenCL 3.0 bietet eine Neuausrichtung des Ökosystems, anstatt der API neue Funktionen hinzuzufügen, mit der Absicht, OpenCL zu ermöglichen, noch mehr Entwickler und Geräte zu erreichen. OpenCL 3.0 macht die gesamte 2x-Funktionalität über den Punkt hinaus optional, sodass sich Anbieter darauf konzentrieren können, die Funktionalität bereitzustellen, die sie für ihre Kunden benötigen, und setzt die Möglichkeit neu, die Messlatte für die Kernfunktionalität höher zu legen.
  
  
• 00:05:00 In diesem Abschnitt wird erklärt, dass OpenCL 3.0 eine neue Spezifikation ist, die mit einer einheitlichen API ausgeliefert wird, die entwickelt wurde, um alle OpenCL 2.x-Funktionen mit zusätzlichen Erweiterungen für DSP-Light-Prozessoren abzufragen, um 2D- und 3D-Daten zwischen global und zu übertragen lokale Speicher flexibel und asynchron über DMA-Transaktionen (Direct Memory Access). Obwohl OpenCL 3.0 die OpenCL C++-Spezifikation nicht enthält, wird anderen Implementierungen empfohlen, den Open-Source-Front-End-Compiler C++ für OpenCL zu verwenden, um Spir-V-Kernel zu generieren, indem OpenCL C mit einem Großteil von C++17 gemischt wird. Die Roadmap für OpenCL beinhaltet die Auslieferung neuer Funktionen als Erweiterungen zuerst für die Einführung in der Industrie, damit sie ausgereift und erprobt werden können, bevor sie in zukünftige Kernspezifikationen integriert werden. Die OpenCL-Arbeitsgruppe sieht Profile auch als ein wichtiges Werkzeug, um Implementierungsflexibilität mit Anwendungsportabilität in Einklang zu bringen und eine Fragmentierung für Zielmärkte zu vermeiden.
  
  
• 00:10:00 In diesem Abschnitt erörtert der Moderator das wachsende Ökosystem von Open-Source-Kernelsprachen-Compilern, zu denen clang und lvm gehören, die Spirit-Kernel für OpenCL Vulcan oder zur weiteren Übersetzung in Shader zur Ausführung auf anderen APIs wie z als Metall. Dies würde OpenCL-Anwendungen auf Apple-Plattformen ermöglichen, ohne OpenCL-Treiber verwenden zu müssen. Der Moderator erwähnt auch das OpenCL 12-Projekt, das LLVM-generierte Spirit-Kernel mithilfe einer Open-Source-Konvertierungspipeline in DXi L übersetzt, wodurch Sprachcompiler unabhängig von Laufzeiten innovativ sein können. Die Spezifikation für OpenCL 3 ist vorläufig, und das Feedback von Benutzern wird ermutigt, die Spezifikation fertigzustellen, während sich die Arbeitsgruppe auf die erste Implementierungswelle in den nächsten Monaten vorbereitet.