OpenCL im Handel - Seite 10

Neuer Kommentar
 

Einfach, effektiv, effizient: GPU-Programmierung mit PyOpenCL und PyCUDA (1)



GPU-Programmierung mit PyOpenCL und PyCUDA (1)

Dieses Video stellt PyOpenCL und PyCUDA vor, Pakete für eine effiziente GPU-Programmierung mit Python. Der Referent betont die Vorteile von OpenCL für seine Flexibilität, mit Geräten anderer Anbieter zu kommunizieren, im Gegensatz zu CUDA von Nvidia. Das Programmiermodell beinhaltet das Indizieren von Informationen, um zwischen verschiedenen Quadraten in einem Gitter zu unterscheiden, was mehr Parallelität und weniger Abhängigkeit von Speicher-Caches ermöglicht. Darüber hinaus ermöglichen PyOpenCL und PyCUDA eine einfache Kommunikation mit und Programmierung von Rechengeräten, wodurch eine schnellere Produktivität ermöglicht und asynchrones Computing erleichtert wird. Der Referent erörtert auch die Bedeutung der Verwaltung des Gerätespeichers und die Verfügbarkeit atomarer Operationen in PyOpenCL und PyCUDA.

  • 00:00:00 In diesem Abschnitt stellt Andreas Faulkner PyOpenCL und PyCUDA als Pakete für eine einfache, effektive und effiziente GPU-Programmierung mit Python vor. Faulkner erklärt, dass PyOpenCL und PyCUDA die Programmierung für GPUs über CUDA oder OpenCL über eine Python-Schnittstelle ermöglichen. Darüber hinaus hebt er die Vorteile von OpenCL aufgrund seiner Flexibilität hervor, mit Geräten anderer Anbieter im Vergleich zu einem CUDA-Gerät von Nvidia zu kommunizieren. Faulkner behauptet, dass es mit GPUs möglich ist, es besser zu machen als mit herkömmlichen CPUs, indem man ein anderes System implementiert, in dem die Anweisungen von einer Vielzahl grober, einfacher Komponenten gesteuert werden. Letztendlich können Programmierer mit PyOpenCL und PyCUDA 16 unabhängige Anweisungen steuern, um wissenschaftliche Rechenlasten auszuführen.

  • 00:05:00 In diesem Abschnitt erörtert der Sprecher die Kernideen von Cindy Acosta, die das Hinzufügen von mehr Parallelität beinhalten, um das Problem der Speicherlangsamkeit zu lösen. Durch Hinzufügen weiterer ALUs und Erhöhen der Menge an gemeinsam genutztem Speicher und Kontextspeicher kann der Chip auch dann weiterhin nützliche Arbeit leisten, wenn er durch Speicherverzögerungen blockiert ist. Das Ziel ist es, eine unendliche Anzahl von Kernen zu programmieren, da es viel einfacher ist, Parallelität in einem Programm auszudrücken, als ein paralleles Programm in ein sequentielles umzuwandeln. Das ultimative Hardwaredesign umfasst 128 unabhängige Befehlssätze, die so organisiert sind, dass mehr Parallelität und weniger Abhängigkeit von Speicher-Caches und Ausführung außerhalb der Reihenfolge möglich sind.

  • 00:10:00 In diesem Abschnitt erklärt der Referent, wie man die Hardware eines Computers in ein Bild abbildet, in dem es unendlich viele Gesamtstrukturen und Ausfälle gibt, mit dem Ziel, die wahre Natur der Hardware zu bewahren. Dies wird erreicht, indem Arbeitsaufgaben definiert werden, wobei ein zweidimensionales Gitter die Anzahl der Arbeitsaufgaben gruppiert. Indem diese Gruppen einer Maschine zugeordnet werden, kann die zusätzliche Parallelität in eine sequentielle Ausführung umgewandelt werden. Das von PyOpenCL und PyCUDA bereitgestellte Programmiermodell verhält sich wie ein Pool von Parallelitäten, in den der Chip hineinfallen kann, wobei nur dann zur sequentiellen Ausführung übergegangen wird, wenn auf dem Chip keine Parallelität mehr vorhanden ist.

  • 00:15:00 In diesem Abschnitt des Videos erklärt der Referent das Programmiermodell der GPU-Programmierung mit PyOpenCL und PyCUDA. Das Modell beinhaltet die mehrfache Ausführung einer einzelnen Funktion, wobei jede Ausführung einem Quadrat in einem Raster entspricht. Um zwischen den verschiedenen Quadraten im Raster zu unterscheiden, werden Indizierungsinformationen verwendet, z. B. lokale und globale IDs, und es wird eine Funktion geschrieben, die diese Informationen verwendet, um auf Daten zuzugreifen. Der Redner erklärt weiter, dass OpenCL die offene Computersprache ist, die für die GPU-Programmierung verwendet wird, die eine Generierung von Laufzeitcode bietet und eine flexible Möglichkeit darstellt, mit verschiedenen Rechenleistungen zu kommunizieren, die in der Box verfügbar sind.

  • 00:20:00 In diesem Abschnitt diskutiert der Redner die Verwendung und Implementierung von OpenCL und gibt an, dass es mindestens drei qualitativ hochwertige Implementierungen davon gibt. Während CUDA schon länger existiert und aufgrund seiner Präsenz auf der NVIDIA-Webseite sichtbarer ist, wurde OpenCL von mehreren Organisationen übernommen, darunter Apple. Der Referent merkt an, dass er einen Kurs über OpenCL gehalten und dies für eine gute Idee gehalten hat, da sich mehrere Studenten für die Verwendung von OpenCL anstelle von CUDA entschieden haben. Darüber hinaus betont der Referent, dass sich OpenCL und CUDA konzeptionell nicht sehr unterscheiden und die Leistungsunterschiede oft künstlich sind.

  • 00:25:00 In diesem Abschnitt erörtert der Referent die Architektur der GPU-Programmierung, beginnend mit dem Host und der Laufzeitschnittstelle, und beschreibt die verschiedenen Plattformen und Recheneinheiten darin. Der Referent stellt dann PyOpenCL und seine Fähigkeit vor, Python die Kommunikation mit und Programmierung der verschiedenen Rechengeräte zu ermöglichen, was neben anderen Vorteilen die Produktivität steigern und Spin-Verarbeitung ermöglichen kann. Die Verwendung von PyOpenCL wird als gut geeignet angesehen, um Rechengeräte aus einer Hochsprache wie Python zu nutzen, ohne sich um technische Details kümmern zu müssen.

  • 00:30:00 In diesem Abschnitt erörtert der Redner den Unterschied zwischen dem Kompilieren zur Kompilierzeit und zur Laufzeit und wie Skripting für GPUs vertretbar ist. Er erklärt, dass es für bestimmten Code, wie z. B. High-Level-Slow-Smoke-Dinge, bei denen Geschwindigkeit nicht so wichtig ist, sinnvoll ist, eine Skriptsprache für die GPU-Programmierung zu verwenden. Da die CPU außerdem darauf beschränkt ist, mehr oder weniger nur ein Verkehrspolizist in der GPU-Programmierung zu sein, kann die Verwendung einer Skriptsprache wie Python sehr schnell sein, um Dinge zu erledigen. Der Referent stellt dann PyOpenCL vor und wie es einem Benutzer ermöglicht, C-Quellcode zur Laufzeit mit nativer Kompilierungsunterstützung auszuführen.

  • 00:35:00 In diesem Abschnitt demonstriert der Moderator die GPU-Programmierung mit PyOpenCL und PyCUDA, indem er mit einem Array von Zufallszahlen beginnt und einen OpenCL-Kontext erstellt, um einen Puffer für die Übertragung der Daten auf die GPU zu erstellen. Anschließend erstellen sie ein CL-Programm, um die Daten zu multiplizieren, und rufen es mit einem Befehl auf einem Gitter der Größe acht auf. Der Moderator betont die Einfachheit des Programms und demonstriert, dass das Programm im Gegensatz zu CUDA auch mit einer größeren Rastergröße noch einwandfrei laufen würde. Abschließend bestätigen sie, dass die gewünschte Ausgabe erzielt wurde, und schlagen vor, weitere Änderungen am Programm vorzunehmen, um das Programmiermodell besser zu verstehen.

  • 00:40:00 In diesem Abschnitt erläutert der Referent das Konzept der Rastergröße und Arbeitsgruppengröße in der PyOpenCL- und PyCUDA-Programmierung. Es ist wichtig zu beachten, dass die globale Rastergröße unabhängig von der Größe der Arbeitsgruppe gleich bleibt. Das Ändern der Arbeitsgruppengröße kann zu erheblichen Leistungsunterschieden führen. Der Referent erörtert auch, wie das Programm geändert werden kann, um eine Gruppe von 16 mal 16 Workouts zu verwenden, und wie ein Benchmarking mit einem Arbeitselement pro Gruppe gegenüber der Verwendung von 256 für die Kategorie durchgeführt werden kann. Dabei ist zu beachten, dass CPU und GPU miteinander kommunizieren und die eigentliche Berechnung asynchron abläuft.

  • 00:45:00 In diesem Abschnitt erklärt der Kursleiter, wie Timings mithilfe von Kernel-Log- und Dot-Wait-Befehlen in PyOpenCL gemessen werden. Beim Benchmarking werden die Zeitmessungen vor und nach dem Kernel-Log notiert und am Ende mit dem dot wait-Befehl sichergestellt, dass der Kernel vollständig ausgeführt wird. Der Kursleiter betont auch, wie PyOpenCL und PyCUDA vollständigen Zugriff auf die zugrunde liegenden Schichten bieten und Ressourcen automatisch verwalten, wodurch es einfacher wird, die Produktivität zu steigern. Darüber hinaus lassen sich diese Bibliotheken nahtlos in andere Frameworks integrieren und funktionieren auf allen wichtigen Betriebssystemen, einschließlich Erweiterungen von Anbietern wie Nvidia.

  • 00:50:00 In diesem Abschnitt erörtert der Sprecher die Verfügbarkeit atomarer Operationen in PyOpenCL und PyCUDA und erklärt, dass sie Teil des Basisteils des Standards sind und nicht emuliert werden, wenn sie nicht in der Hardware verfügbar sind. Der Redner erwähnt auch die Verwendung der Zeichenfolgendarstellung bei der Codegenerierung, die ihrer Meinung nach auf PyOpenCL aufbauen würde. Der Abschnitt endet damit, dass der Redner die Bedeutung einer sorgfältigen Verwaltung des Gerätespeichers betont und auf die Verfügbarkeit von Dokumentation zu PyOpenCL und PyCUDA verweist.

  • 00:55:00 In diesem Abschnitt erklärt der Referent, wie PyOpenCL und PyCUDA Programmierer produktiver machen und ihnen wertvolle Zeit sparen können, wenn sie Aufgaben programmieren, die mit Open-Source-Bibliotheken trivial wären. Sie können auch einen Hype um Python erzeugen und Programmierern, die C++ nicht kennen, das schnelle Schreiben von Programmen erleichtern. Die Verwendung mehrerer Kontexte in Open CL kann dabei helfen, die umfangreichen Berechnungen eines Programms aus einer einzigen Quelle zu koordinieren.
 

Einfach, effektiv, effizient: GPU-Programmierung mit PyOpenCL und PyCUDA (2)



GPU-Programmierung mit PyOpenCL und PyCUDA (2)

Das Video behandelt verschiedene Aspekte der GPU-Programmierung mit PyOpenCL und PyCUDA. Der Referent erklärt, wie wichtig es ist, den Kontext des Programms zu verstehen, und hebt die Schlüsselkomponenten des Laufzeit- und Gerätemanagements hervor. Sie bieten wertvolle Einblicke in Befehlswarteschlangen, Synchronisierung, Profilerstellung und den Puffer in PyOpenCL und PyCUDA. Das Video geht auch darauf ein, wie Code in einem Kontext ausgeführt wird, indem ein Programm aus dem Quellcode erstellt wird, und betont die Bedeutung der Verwendung elementweiser Operationen und Synchronisierungsfunktionen im Gerät. Der Referent schließt mit einer Erörterung der Vorteile des Staging-Bereichs und ermutigt die Teilnehmer, andere gerätespezifische Vorgänge zu erkunden, die als Hooks verfügbar sind.

  • 00:00:00 In diesem Abschnitt gibt der Referent einen Überblick über die Programmier-Frameworks PyOpenCL und PyCUDA und erörtert die Konzepte und Komponenten der Laufzeit- und Geräteverwaltung. Der Referent betont, wie wichtig es ist, den Kontext des Programms zu verstehen und wie man mit der OpenCL-Laufzeitumgebung mit verschiedenen Geräten kommuniziert. Der Redner geht auch auf die Implementierungsdetails von OpenCL ein und hebt insbesondere die Apple-Implementierung hervor. Der Referent schließt mit einem Rundgang durch den „Spielzeugladen“, der einen Überblick über die verschiedenen Komponenten gibt, aus denen PyOpenCL und PyCUDA bestehen.

  • 00:05:00 In diesem Abschnitt weist der Sprecher darauf hin, dass PyOpenCL und PyCUDA einen ICD-Loader verwenden, um die tatsächliche Implementierung gemeinsam genutzter Bibliotheken in einem Verzeichnis über dynamische Ladevorgänge zu finden. Plattformen bieten Gruppen von Geräten mit eigenen Kontexten, und sobald das Gerät ausgewählt ist, können Benutzer einen Kontext erstellen, indem sie es dem gewünschten Gerät zuweisen. Kontext kann mehrere Geräte umfassen und zum Erstellen von Programmen und Befehlen verwendet werden. Der Zweck von Befehlen besteht darin, zwischen dem Host und dem Gerät zu vermitteln und asynchron auszuführen. Der Referent erklärt, dass die Arbeit an eine Warteschlange gesendet wird, die standardmäßig sequenziell ist, und stellt fest, dass mehrere Warteschlangen auf einem Gerät aktiv sein können, was eine parallele Verarbeitung ermöglicht.

  • 00:10:00 In diesem Abschnitt erklärt der Referent, wie man die GPU-Programmierung mit PyOpenCL und PyCUDA einrichtet. Er erläutert das Erstellen von Befehlswarteschlangen, die gerätespezifisch sind und mehrere Eigenschaften haben können, einschließlich Profilerstellung. Anschließend demonstriert er die Verwendung eines Intel-Prozessors für die Vektoraddition und erklärt die Bedeutung von Ereigniskennungen für die Überwachung von Betriebszeiten. Insgesamt betont der Referent die Nützlichkeit von Command Queues für die GPU-Programmierung.

  • 00:15:00 In diesem Abschnitt erläutert der Referent die Bedeutung der Synchronisierung zwischen Hosts und Ereignissen beim parallelen Rechnen mit PyOpenCL und PyCUDA. Sie besprechen, wie auf mehrere Ereignisse gleichzeitig gewartet wird und Mitglieder der Befehlswarteschlange aufeinander warten, um ein sicheres Umschalten zwischen Warteschlangen zu gewährleisten. Der Referent diskutiert auch die Datenabhängigkeit und wie sie in der Implementierung ausgedrückt werden kann, um die Geräte darüber zu informieren, wie die Dinge voneinander abhängen. Darüber hinaus ermöglicht die Verwendung von Profiling ein feinkörniges Timing und eine präzise Aufzeichnung von Ereignissen, die sehr detaillierte Leistungsdaten liefern.

  • 00:20:00 In diesem Abschnitt erklärt der Referent, wie Profiling in der GPU-Programmierung funktioniert und wie man die Ausführungszeit abschätzt. Er erläutert auch die Verwendung von Markierungen im Code und wie man die Timing-Daten erhält. Der Referent stellt gerichtete azyklische Graphen vor und wie sie bei der Kommunikation zwischen mehreren Ausführungsströmen auf verschiedenen GPUs verwendet werden können, sowie die Bedeutung der Synchronisierung und des Abhängigkeitsmanagements beim Umgang mit Speicher. Insgesamt gibt der Referent wertvolle Einblicke in die verschiedenen Aspekte der GPU-Programmierung mit PyOpenCL und PyCUDA.

  • 00:25:00 In diesem Abschnitt erörtert der Redner den Puffer in PyOpenCL und PyCUDA, bei dem es sich um einen Speicherblock ohne Typinformationen handelt, der an einen Kernel gesendet werden kann, der sich auf einem anderen Gerät befindet. Die Pufferabstraktion bietet eine vollständige Isolierung vom Speicherort der Daten und stellt sicher, dass alles effizient bleibt, wenn es innerhalb desselben Geräts passiert. Der Sprecher erläutert auch drei verschiedene Arten der Speicherzuweisung: Kopieren, Host-Zeiger verwenden und Zuordnen. Die Implementierung verfügt über alle Informationen, die sie benötigt, um zu wissen, von welchem Gerät die Daten durchlaufen werden müssen, um am effizientesten zu sein. Der Preis dafür ist jedoch, dass es teuer sein kann, Daten von einem Gerät auf ein anderes zu übertragen.

  • 00:30:00 In diesem Abschnitt erklärt der Redner, wie man es vermeidet, die "Post"-Technik der Datenübertragung zu durchlaufen, indem man dem Inhalt einen Puffer zuordnet und die Daten dorthin überträgt. Sie stellen jedoch fest, dass eine Folge des Fehlens eines physischen Speicherorts für den Puffer die Unfähigkeit ist, Zeiger auf die Basis zu haben, die über die Lebensdauer eines Kernels hinaus bestehen. Der Sprecher erwähnt auch, dass Benutzer in einem Cluster die Wahl haben, einen Kontext zu erstellen, der eine einzige Ansicht aller OpenGL-Geräte im gesamten Cluster auf einer Maschine sendet, die das steifste Vokabular in der gesamten ersten Reihe ausnutzen kann. Um den Speicherort zu erhalten, hängt der Benutzer einen Puffer an einen Kontakt an, und die Implementierung hat keine Ahnung, für welches Gerät der Speicher aktiver Code ist.

  • 00:35:00 In diesem Abschnitt erklärt der Referent, wie Indizes verwendet werden, um auf Vektoren und Puffer in PyOpenCL und PyCUDA zu verweisen. Puffer können über den Speicher und den Host spezifiziert und so instanziiert werden, dass bestimmte Anforderungen erfüllt werden. Eine Möglichkeit, dies zu tun, besteht darin, das Transkript zu sperren, um den Speicherplatz für die Verwendung freizugeben. Der Redner weist darauf hin, dass es normalerweise ratsam ist, Übertragungen standardmäßig zu blockieren, da dies sicherstellt, dass die Speicherübertragung stattfindet, bevor Daten wiederverwendet werden.

  • 00:40:00 In diesem Abschnitt erläutert der Sprecher, wie Code in einem Kontext ausgeführt wird, indem ein Programm aus dem Quellcode erstellt wird. Der Sprecher merkt an, dass Benutzer den Kernel in bestimmte Gebäude- und Innenargumente einbeziehen und andere Dinge oszillieren können. Argumente können ein Nullzeiger, numpy-Größenskalare oder alles mit einer Pufferschnittstelle sein. Es ist jedoch wichtig, diese Argumente richtig zu zählen. Der Redner teilt mit, dass es eine Möglichkeit gibt, Ganzzahlen mit expliziter Größe jedes Mal zu vermeiden, indem man OpenCL im Voraus über die Datentypen des Skalarsichters informiert und vermeidet, sie zu vergessen. Zusätzlich erwähnt der Referent den Geräte-Manager, mit dem sich Geräte und deren Speicherplatz in Sekundenschnelle qualifizieren lassen. Eine Möglichkeit, Ganzzahlen mit expliziter Größe jedes Mal zu vermeiden, indem OpenCL im Voraus über die Datentypen des gesichteten Skalars informiert wird und sie nicht vergessen werden.

  • 00:45:00 In diesem Abschnitt erörtert der Redner einige verwirrende und nicht intuitive Entscheidungen in PyOpenCL und PyCUDA, wie z. B. die Namenskonventionen für Speicherbereiche und die Unterschiede zwischen globalem und lokalem Speicher. Sie heben auch die Verwendung von Speicherbereichen wie Geräte-, privatem und lokalem Speicher sowie strukturierten Bildern und Reise-IDs hervor. Trotz der Herausforderungen betont der Referent, wie wichtig es ist, diese Merkmale zu kombinieren, um erfolgreiche Algorithmen zu schreiben, und hebt die Nützlichkeit der Zuordnung zu Komponenten hervor.

  • 00:50:00 In diesem Abschnitt erläutert der Referent die Vorteile der Verwendung elementweiser Operationen wie Sinus- und Kosinusfunktionen beim Programmieren mit PyOpenCL und PyCUDA. Er erklärt weiter, dass diese Funktionen hilfreich sind, da Sie den Vektor wie einen Skalar behandeln und von Inkrementen in der Nähe eines Lichts laden und speichern können. Er weist auch darauf hin, wie wichtig es ist, Synchronisierungsfunktionen im Gerät wie Barrieren und Speicherzäune zu haben, die es Ihnen ermöglichen, zwischen Kernel-Starts und innerhalb des Kernels zu synchronisieren. Die Speicherzäune sind auch wichtig, um die Speicheroperationen vor Ihnen zu steuern, um Konflikte bei der Reihenfolge zu vermeiden.

  • 00:55:00 In diesem Abschnitt erklärt der Sprecher den Zweck des Staging-Bereichs zur sicheren Aufbewahrung von variablem Riff, wo Daten zwischen CPU und GPU für einen unterbrechungsfreien und öffentlichen Betrieb gebracht werden können. Der Referent erwähnt auch die PyOpenCL, die gerätespezifische Operationen auf unterster Ebene verpackt und verfügbar macht. Darüber hinaus stellt der Referent die "swap"-Operation vor, die willkürliche und komplizierte Operationen erlaubt, die mit Comic festgeschrieben werden. Der Redner ermutigt die Teilnehmer, weitere Fragen zu stellen oder andere gerätespezifische Vorgänge zu untersuchen, die als Hooks verfügbar gemacht werden.
 

Einfach, effektiv, effizient: GPU-Programmierung mit PyOpenCL und PyCUDA (3)



GPU-Programmierung mit PyOpenCL und PyCUDA (3)

In diesem Abschnitt der Videoserie zur GPU-Programmierung mit PyOpenCL und PyCUDA erörtert der Moderator verschiedene Themen, darunter die Optimierung von Code mit Attributen, Speicherverwaltung, Codegenerierung und die Vorteile der Verwendung von PyOpenCL und PyCuda. Der Referent betont die Vorteile der Generierung mehrerer Codevarianten zur Laufzeit und erklärt, wie das Ersetzen von Zeichenfolgen, das Erstellen eines Syntaxbaums und die Verwendung von Python und Performing-Sprachen dazu beitragen können, flexiblen und effizienten Code zu erstellen. Der Referent warnt auch vor potenziellen Fallstricken bei der Verwendung von Kontrollstrukturen in Python, zeigt aber, wie ein abstrakter Ansatz zur Analyse von Algorithmen zur Verbesserung der Parallelität beitragen kann. Insgesamt bietet das Video wertvolle Einblicke und Tipps zur Optimierung der GPU-Programmierung mit PyOpenCL- und PyCUDA-Bibliotheken.

Das Video erörtert auch Strategien zur Bewertung und Auswahl verschiedener Codes für die GPU-Programmierung. Profiling wird empfohlen, mit Analyse von Befehls- und Ereignisausgaben, um festzustellen, wann der Code übermittelt wurde und wie lange die Ausführung dauerte. Weitere Auswertungsmöglichkeiten sind die Analyse des NVIDIA-Compiler-Logs und die Beobachtung der Laufzeit des Codes. Das Video behandelt auch eine Suchstrategie zum Finden der besten Werte für eine Gruppe in der PyCUDA- und PyOpenCL-Programmierung. Der Referent empfiehlt die Verwendung eines Profilers zur Analyse der Programmleistung und erwähnt die Auswirkungen von Workarounds für Nvidia-Profiling-Patches auf die Code-Ästhetik.

  • 00:00:00 In diesem Abschnitt des Videos überprüft der Moderator die OpenCL-Spezifikation, die er gut geschrieben und leicht lesbar findet. Darüber hinaus erinnert er die Zuschauer daran, sicherzustellen, dass der Garbage Collector den Speicher nicht beeinträchtigt, wenn er eine Übertragung vom Speicher eines Hosts auf das Gerät initiiert. Der Moderator erläutert im Folgenden implizite und explizite Arbeitsgruppen und zeigt, wie AutoTune verschiedene Codeversionen generiert, damit Entwickler die am besten geeignete auswählen können. Schließlich zeigt er ein von ihm entworfenes Spielzeug, das die Bewegung von Partikeln auf einem Gitter visualisiert.

  • 00:05:00 In diesem Abschnitt erklärt der Referent, wie bestimmte Attribute verwendet werden können, um dem Compiler zusätzliches Wissen zu vermitteln und die Leistung des Codes zu verbessern. Er erwähnt zwei Attribute, die angegeben werden können – type und die erforderliche Arbeitsgruppengröße XY Z. Type teilt dem Compiler mit, dass die Hauptberechnungseinheit im Code beispielsweise Float sein wird, und der Compiler kann Entscheidungen darüber treffen, welche Register verwendet werden wird wie sein. Die erforderliche Arbeitsgruppengröße XYZ kann verwendet werden, um dem Compiler dabei zu helfen, Multiplikationsaufgaben schneller auszuführen und das Zugriffsmuster zu optimieren. Der Redner erwähnt auch Speicher mit Seitensperre, also Speicher, der näher am Prozessor liegt und auf den zugegriffen werden kann, ohne den Host um Hilfe zu bitten. Es ist in OpenGL hinter dem Post-Zeiger der Befehlswarnung verborgen und kann bei der GPU-Programmierung nützlich sein.

  • 00:10:00 In diesem Abschnitt erörtert der Redner den Speicher und wie er sowohl vom GPU- als auch vom Host-Adressraum zugänglich ist, und stellt fest, wie er für OpenCL und CUDA funktioniert, wobei einige Einschränkungen wie das Fehlen von Texturierung aus linearem Speicher in OpenCL bestehen. Der Redner erwähnt auch, wie Apples Implementierung von OpenCL anders ist, mit Funktionen wie einem Cache, der beim Debuggen problematisch sein kann. Darüber hinaus stellt der Sprecher fest, dass Intel angeblich OpenCL nicht mag und seine eigenen Sachen vorantreibt, während Apple sie stark bewaffnet hat, um Elefantenohren zu beklagen. Abschließend schlägt der Redner vor, dass es sich lohnt, die GPU-Implementierung von AMD zu prüfen, insbesondere für superkopflastige Arbeiten, die einen Haufen mehr Fließkommaleistung erfordern.

  • 00:15:00 In diesem Abschnitt erörtert der Referent die Codegenerierung, bei der zur Laufzeit mehrere Codevarianten erstellt werden, um den Code an unterschiedliche Situationen anzupassen. Das Generieren von Code ist aus mehreren Gründen eine nützliche Idee, einschließlich der automatischen Optimierung und der Anpassung an eine Vielzahl von Benutzeranforderungen, z. B. unterschiedliche Datentypen. Der Redner schlägt vor, dass Python eine hervorragende Möglichkeit ist, Textverarbeitung durchzuführen und Code zu generieren.

  • 00:20:00 In diesem Abschnitt erläutert der Referent, wie man Flexibilität in enge innere Codeschleifen bringt. Er erklärt, dass es beim Schreiben von Bibliotheken wichtig ist, Flexibilität an einem Punkt zuzulassen, an dem sich der Code in einer engen inneren Schleife befindet. Er nennt drei Hauptwege, um diese Flexibilität zu erreichen: Ersetzen von Zeichenfolgen, Erstellen eines Syntaxbaums und Generieren von Code. Der Redner merkt auch an, dass die Verwendung einer Kombination aus Python und einer leistungsfähigen Sprache wie PyOpenCL oder PyCUDA dazu beitragen kann, die Stärken jeder Sprache auszunutzen und einen vernünftigen Weg zu schaffen, Code zu erstellen, der nicht zu schlüpfrig ist. Abschließend erläutert er die Vorteile der NumPy-Bibliothek für die lineare Algebra und wie sie Ihnen zusätzlich zur Laufzeit-Kogeneration helfen kann.

  • 00:25:00 In diesem Abschnitt erörtert der Referent die Vorteile der Verwendung von PyOpenCL und PyCuda, zwei Python-Bibliotheken für die GPU-Programmierung. Diese Bibliotheken ermöglichen das beliebige Mischen von Typen und können die Vektorisierung von Operationen effektiv handhaben. Bei der Arbeit mit Ausdrucksauswertungen verwenden diese Bibliotheken eine Einrichtung, die als elementweiser Kernel bezeichnet wird und die Notwendigkeit vermeiden kann, temporäre Arrays zu erstellen und anschließend zu verwerfen. PyOpenCL und PyCuda bieten auch Möglichkeiten für parallele Datenoperationen, wie z. B. elementweise kumulative Reduktion, die Operationen wie das Summieren von Dingen über den Halter ausführen kann. Der Referent kommt zu dem Schluss, dass diese Bibliotheken es ermöglichen, alle unterschiedlichen Kombinationen von Datentypen einfach zu handhaben, während gleichzeitig laufende Operationen entweder parallel oder sequenziell ausgeführt werden.

  • 00:30:00 In diesem Abschnitt erörtert der Moderator die Vorteile, einen Skalar auf der GPU zu belassen, anstatt ihn hin und her zu übertragen, was zu Ineffizienzen führen kann. Er spricht auch über Templating-Engines, die Webseiten generieren und verschiedene Schlüsselwörter in einem Codeskript ersetzen können. Der Moderator betont, dass diese Techniken keine Zauberei sind, sondern einfache und nützliche Werkzeuge, die Programmierern großen Nutzen bringen können.

  • 00:35:00 In diesem Abschnitt erläutert der Moderator die Verwendung von Templating-Engines zur Vereinfachung des Prozesses der Codegenerierung, indem er anhand von Beispielen zeigt, wie der Prozess funktioniert. Die Templating-Engine ermöglicht die Verwendung von Python-Ausdrücken zwischen Dollarzeichen, die dabei helfen können, Schleifen aufzurollen und Erweiterungen zu erstellen. Die resultierende Ausgabe ist Quellcode, der dann manuell in die CL eingespeist werden muss. Der Moderator beantwortet Fragen aus dem Publikum, während sie versuchen, den Prozess zu verstehen.

  • 00:40:00 In diesem Abschnitt diskutiert der Redner die Verfügbarkeit von Kontrollstrukturen, die Python unterstützt, warnt aber davor, dass dies dem Programmierer viele Seile gibt, an denen er sich aufhängen kann, wenn er nicht aufpasst. Sie sprechen weiter über das Reduktionsbeispiel und erklären, wie Code mit beliebigen Möglichkeiten generiert werden kann, da PyOpenCL über eine Python-Funktion verfügt, mit der Sie alle neuen Nächte ignorieren oder einbeziehen können. Sie kommen zu dem Schluss, dass PI den Syntaxbaum öffnet und es kaum vertretbar ist, diese Copy-and-Paste-Methode anzuwenden.

  • 00:45:00 In diesem Abschnitt erklärt der Sprecher, dass, wenn ein Benutzer Aufgaben auf gut strukturierte Weise durch strukturelles Generieren von Code ausführt, dies zum Erstellen bestimmter Teile eines Projekts funktionieren könnte, aber möglicherweise nicht zum Erstellen eines Projekts geeignet ist ganzes Projekt. Der Redner fährt fort, ein Beispiel dafür zu erörtern, wie eine Vektoraddition und -reduktion durchgeführt wird, die als Funktion der ersten beiden und dann als eine weitere Funktion des Ergebnisses betrachtet und unter Verwendung eines baumbasierten Ansatzes implementiert wird. Der Benutzer wird dann gebeten, sich für den Arbeitsaufwand zu entscheiden, den er erledigen und auf den er warten möchte, gefolgt von einer grafischen Darstellung, wie alles funktioniert.

  • 00:50:00 In diesem Abschnitt erklärt der Referent, wie die Parallelität in der vorherigen Codeversion verbessert werden kann, um sie effizienter zu machen. Sie schlagen vor, einen abstrakten Ansatz zu verwenden, um Algorithmen basierend auf Arbeit und Arbeitsbelastung zu analysieren, um festzustellen, wie parallel die Aufgabe ist. Sie erwähnen das Ziel des Unternehmens, die Laufzeit auf Worker-Größe und Abhängigkeiten auszugleichen, um die Parallelität zu verbessern. Sie geben auch ein Beispiel für die endgültige Version des Reduktionscodes, der Variablen, mathematische Ausdrücke enthält und Ausdrücke direkt reduziert. Anschließend demonstrieren sie die Codegenerierung zur Verbesserung der Leistung und zur doppelten Unterstützung.

  • 00:55:00 In diesem Abschnitt erläutert der Referent die Implementierung des Reduktionsausdrucks mit PyOpenCL und PyCUDA mit Beispielen, wie Code für eine bestimmte Anzahl von Elementen generiert wird. Sie erwähnen die Verwendung von Template-Metaprogrammierung in PyCUDA und wie schwer verständlich sie sein kann. Der Redner argumentiert, dass die Fähigkeit von PyOpenCL und PyCUDA, eine Vielzahl von Codes aus einer einzigen Quelle ohne Redundanz zu generieren, es zu einem nützlichen Werkzeug macht.

  • 01:00:00 In diesem Abschnitt des Videos erläutert der Sprecher, wie verschiedene Codes für die GPU-Programmierung bewertet und zwischen ihnen ausgewählt werden. Sie schlagen vor, Profiling zu verwenden, das mit dem Befehl Q aktiviert werden kann, und die Befehls- und Ereignisausgaben zu analysieren, um festzustellen, wann der Code gesendet wurde und wie lange er ausgeführt wurde. Weitere Bewertungsmöglichkeiten sind die Analyse des NVIDIA-Compiler-Logs, die Berechnung der bereitgestellten Dollars und die Beobachtung der Laufzeit des Codes. Wenn die Anzahl der auszuwertenden Codes das übersteigt, was in einer Mittagspause erledigt werden kann, schlagen sie vor, entweder eine umfassende Suche durchzuführen oder orthogonale Suchmethoden zu verwenden, wie sie beispielsweise von Mike Ritas Compiler-Cache bereitgestellt werden.

  • 01:05:00 In diesem Abschnitt erörtert der Referent eine Suchstrategie zum Finden der besten Werte für eine Gruppe in der PyCUDA- und PyOpenCL-Programmierung. Die Strategie besteht darin, eine Gruppe zu finden, alle Optionen aufzuschreiben und eine lokale Zielsuche durchzuführen. Der Redner teilt auch mit, dass die meisten Dinge, nach denen Menschen suchen, relativ einfach sind und eine Expertenmeinung bei der Optimierung von Code wertvoll sein kann. Der Referent empfiehlt die Verwendung eines Profilers zur Analyse der Programmleistung und erwähnt, dass der Code aufgrund von Workarounds für Nvidia-Profiling-Patches möglicherweise nicht schön ist.
 

Einfach, effektiv, effizient: GPU-Programmierung mit PyOpenCL und PyCUDA (4)



GPU-Programmierung mit PyOpenCL und PyCUDA (4)

Diese Videoserie behandelt verschiedene Themen im Zusammenhang mit der GPU-Programmierung mit PyOpenCL und PyCUDA. Der Referent teilt Codebeispiele und erörtert den Entwicklungszyklus, die Kontexterstellung und die Unterschiede zwischen den beiden Tools. Sie berühren auch die Kollisionserkennung, diskontinuierliche Galerkin-Methoden, Variationsformulierungen von PDEs und die Optimierung der Matrix-Vektor-Multiplikation. Darüber hinaus spricht der Referent über die Herausforderungen von Computing-Matrix-Produkten und beleuchtet die Leistungsunterschiede zwischen CPU und GPU in Bezug auf die Speicherbandbreite. Das Video schließt mit der Betonung der Bedeutung der Leistungsoptimierung bei der Verwendung von PyOpenCL und PyCUDA.

Das Video erörtert auch die Vorteile der Kombination von Scripting und Laufzeitkogeneration mit PyOpenCL und PyCUDA. Der Referent erklärt, dass dieser Ansatz die Anwendungsleistung verbessern und Zeitschritte weniger herausfordernd machen kann. Bei der Demonstration der Maxwell-Lösungsflugzeuge und Inhalationskräfte waren die Vorteile offensichtlich. Der Redner schlägt vor, dass die Verwendung dieser Tools in Kombination eine großartige Idee ist und dass Potenzial für weitere Untersuchungen besteht.

  • 00:00:00 In diesem Abschnitt teilt der Sprecher seinen Code, der PyOpenCL ähnelt, jedoch in PyCUDA für die GPU-Programmierung. Er weist den Speicher für Gerätekopien zu und zeigt den Kernel, der die Multiplikation von Elementen durchführt. Er erwähnt auch, wie sie mehr als eine Geräteadresse haben können, und ein wenig über die Funktionalität von PyCUDA im Vergleich zu PyOpenCL. Schließlich diskutiert er Vektorberechnungen mit dünnbesetzten Matrizen und wie der konjugierte Gradient eine Entscheidung darüber treffen kann, ob er basierend auf dem inneren Prozess konvergieren kann, sodass die Berechnung fortgesetzt werden kann, während die Daten zwischen CPU und GPU hin und her übertragen werden.

  • 00:05:00 In diesem Abschnitt erörtert der Sprecher den Entwicklungszyklus der Verwendung einer Skriptsprache im Gegensatz zu einem kompilierten Code für die GPU-Programmierung und die Nachteile der ersteren. Sie erklären, dass ein kompilierter Code zwar hilft, Fehler während der Kompilierung zu finden und die Leistung zu verbessern, eine Skriptsprache dies jedoch nicht zulässt. Sie behaupten jedoch, dass die PyCUDA- und PyOpenCL-Pakete helfen können, dieses Problem zu beseitigen, indem sie es einem ermöglichen, den Compiler aufzurufen und die Wartezeit zwischen den Aufrufen zu vermeiden. Darüber hinaus erwähnen sie die Unterscheidung zwischen Laufzeit-API und Treiber-API und die Anforderung, die Laufzeit-API-Bibliotheken den Kontext erstellen zu lassen, in dem man arbeitet.

  • 00:10:00 In diesem Abschnitt erläutert der Referent die Unterschiede zwischen PyOpenCL und PyCUDA. Das Kontextobjekt in beiden Werkzeugen kann auf unterschiedliche Weise erstellt werden. Für beide ist jedoch eine Dokumentation verfügbar, die es Benutzern erleichtert, Kernel zu entwickeln. Der Referent ermutigt zur Verwendung von Mikro-Benchmarks, um die Leistung zu modellieren und so die Leistung beim Schreiben von intelligentem Code zu optimieren. Anschließend zeigen sie, wie die Kollisionserkennung so definiert werden kann, dass sie für eine Reihe von Problemen der linearen Algebra gut funktioniert.

  • 00:15:00 In diesem Abschnitt diskutiert der Redner ein Modell, das verwendet wird, um den Prinzipal zu spezifizieren, der nicht ausreicht, um die Entfernung zu erfassen, erkennt jedoch an, dass es nicht ausreicht, alles zu erfassen. Anschließend teilt er Code zum Laden von Daten in den gemeinsam genutzten Speicher und iteriert durch die Möglichkeit eines Kernels. Der Referent spricht über die Optimierung für bestimmte Lösungen und wie eine Variable innerhalb einer Schleife möglicherweise wiederverwendet werden kann. Anschließend erläutert er die diskontinuierliche Galerkin-Methode, eine Finite-Elemente-Methode, die für zeitabhängige Erhaltungsbindungen verwendet wird. Das Verfahren umfasst das Integrieren nach Teilen und das Erhalten eines Grenzterms über die Elemente hinweg, mit der Möglichkeit, über die Grenze des Elements zu integrieren.

  • 00:20:00 In diesem Abschnitt diskutiert der Referent die Herausforderung, wie mit zwei verschiedenen gültigen Werten an der Schnittstelle der Regierungsschnittstelle umgegangen werden soll, da die Testfunktion und der Lösungsraum Diskontinuitäten tragen. Der Referent schlägt vor, die Theorie der Riemann-Löser zu verwenden, die für eine Finite-Volumen-Methode entwickelt wurde. Durch Lösen eines Erhaltungsgesetzprinzips und Auswählen eines der beiden Werte entlang der Schnittstelle kann eine schwache Formanta erzeugt werden. Dieser Ansatz ermöglicht die Kommunikation zwischen verschiedenen Werten, während die Gleichung gelöst wird. Es gibt verschiedene mathematische Schemata, die verwendet werden können, aber die Verwendung eines Riemann-Lösers kann die Gleichung so lösen, dass sie in den Lösungsraum fällt.

  • 00:25:00 In diesem Abschnitt erörtert der Referent die Formulierung der Variationsformulierung von PDE, bei der Basisfunktionen ersetzt werden, um elementweise Matrizen einzuführen, und die resultierende innere Produktansicht führt zu einer Massenmatrix. Sie diskutieren auch die Inversion der Massenmatrix, die für ein ziemlich einfaches Schema Element für Element durchgeführt werden kann, und die Vereinfachung des Schemas unter Verwendung des EG, das sich gut für lokal dichte Daten eignet und typischerweise als High verwendet wurde -Bestellmethode.

  • 00:30:00 In diesem Abschnitt erörtert der Referent die Rechenintensität der Verwendung höherer Ordnungen, was die Verwendung von PyOpenCL und PyCUDA für die GPU-Programmierung zu einer attraktiven Option macht. Beim Umgang mit linearen Naturschutzgesetzen müssen aufgrund ihrer Komplexität bestimmte Entscheidungen getroffen werden, und wenn es um mittlere Ports geht, wird das Geschäft überschaubarer. Die asymptotische Laufzeit wird von zwei Matrix-Vektor-Produkten pro Element dominiert, und bestimmte Berechnungen sind profitabler als Tensorproduktelemente. Der verwendete Approximationsraum ist lokal um den globalen Dorfraum herum, und das Ausnutzen der Tensorproduktstruktur bietet keinen Vorteil.

  • 00:35:00 In diesem Abschnitt untersucht das Video, wie die Matrix-Vektor-Multiplikation optimiert werden kann, indem die Arbeitslast auf verschiedene Arbeiter aufgeteilt wird. Der Redner erörtert den Kompromiss zwischen der Verwendung eines Elements pro Worker oder mehrerer Elemente pro Worker unter Berücksichtigung von Faktoren wie Speichernutzung und koaleszierendem Speicherzugriff. Sie untersuchen auch die Wahl zwischen Computing mit elementweiser Granularität oder Gruppengranularität und wie man die Wiederverwendung von Daten und Parallelität in Einklang bringt. Das Video schließt mit der Feststellung, dass diese Entscheidungen von verschiedenen Faktoren wie der Matrixgröße und der Größe des Ausgabepuffers abhängen.

  • 00:40:00 In diesem Abschnitt des Videos zur GPU-Programmierung mit PyOpenCL und PyCUDA erörtert der Referent die Granularität in Berechnungen und das Mindestmaß an Granularität, das für eine Berechnung erforderlich ist, um eine 70 zu füllen und somit die Anforderungen an das Auffüllen von Bereichen mit einem Vielfachen davon zu erfüllen Mindestebene der Granularität, die für andere Berechnungen erzwungen wird. Der Leistungsaspekt und der Flexibilitätsaspekt des Codes werden diskutiert, wobei der Referent eine Grafik präsentiert, die die Abfolge paralleler Dinge in Bezug auf die Größe der Box zeigt, und den dauerhaften Wert der Leistungssteigerung des Codes im Gegensatz dazu betont sich auf die Hardware zu verlassen. Auch eine Variationsformulierung und der Flussterm werden aus CS-Perspektive beleuchtet.

  • 00:45:00 In diesem Abschnitt erörtert der Sprecher die Herausforderung, eine enge innere Schleife aus einem in mathematischer Notation geschriebenen Papier zu transkribieren und in Code zu implementieren. Um dieser Herausforderung zu begegnen, sollte die Implementierung eng mit der mathematischen Notation des Papiers übereinstimmen. Darüber hinaus bietet das Vorhandensein einer Denkebene zwischen dem ausgeführten Code und dem Code des Benutzers einen nicht zu vernachlässigenden Vorteil der Codegenerierung. Der Referent erklärt, dass mit PyOpenCL und PyCUDA Hochleistungscode geschrieben werden kann und dass die Leistung mit einer von Hand abgestimmten Implementierung im High-End-Bereich vergleichbar ist. Sie stellen auch fest, dass sie die Speicherbandbreite auf einer GTX 280 überschreiten und dass die Verwendung von zusätzlichem Cache die Leistung verbessert.

  • 00:50:00 In diesem Abschnitt erörtert der Referent die Herausforderungen bei der Berechnung von Matrixprodukten aufgrund des begrenzten Speicherplatzes. Trotz der Recheneffizienz reicht der Speicher nicht aus, um die gesamte Arbeit zu speichern, und die Forscher müssen die Matrix in kleinere Bits zerlegen, um die Operationen auszuführen. Sie betonen auch, dass das Matrixprodukt, das bei kurzen und dicken Datensätzen gut funktioniert, nicht einfach mit GPU-Systemen abzustimmen ist, da niemand es für GPUs optimiert. Obwohl CPUs triviale Triple-Loop-Matrix-Matrix für kurze Datensätze effizienter verarbeiten können, ist das GPU-System immer noch besser – mit 16 GPUs, die im Vergleich zu 64 Superior Court-PCs schneller arbeiten.

  • 00:55:00 In diesem Abschnitt geht der Referent auf die Leistung von CPU und GPU in Bezug auf die Speicherbandbreite und den praktischen Vergleich realer Szenarien ein. Er betont auch, dass es für praktische Zwecke besser ist, die tatsächliche Leistung mit der theoretischen Spitzenleistung zu vergleichen, als die Anzahl der Kerne, die der Maschine hinzugefügt werden. Der Redner spricht auch über das Potenzial zur Verbesserung der Leistung bei Verwendung doppelter Genauigkeit und erwähnt die Möglichkeit, die Berechnung zu manipulieren, um bessere Ergebnisse zu erzielen, ohne die Genauigkeit der Berechnung zu beeinträchtigen. Der Abschnitt endet damit, dass der Redner einige der Schlüsselfragen in Bezug auf Zeitintegration und Akteure in der GPU-Programmierung mit PyOpenCL und PyCUDA hervorhebt.

  • 01:00:00 In diesem Abschnitt des Videos spricht der Sprecher über die Vorteile der Verwendung von Scripting und Laufzeitkogeneration zusammen mit PyOpenCL und PyCUDA. Er erklärt, dass es mehrere Vorteile bieten kann, wie z. B. weniger schmerzhafte Zeitschritte und eine verbesserte Leistung von Anwendungen, wie die im Video gezeigten Maxwell-Lösungsebenen und Inhalationskräfte zeigen. Abschließend sagt er, dass die gemeinsame Verwendung dieser Tools eine großartige Idee sein kann und dass sicherlich noch mehr getan werden kann.
 

Par Lab Boot Camp @ UC Berkeley – GPU-, CUDA-, OpenCL-Programmierung



Par Lab Boot Camp @ UC Berkeley – GPU-, CUDA-, OpenCL-Programmierung

In diesem Video gibt der Referent einen Überblick über die GPGPU-Berechnung, wobei er sich hauptsächlich auf CUDA und OpenCL konzentriert. Das CUDA-Programmiermodell zielt darauf ab, GPU-Hardware zugänglicher und inhärent skalierbar zu machen, wodurch eine parallele Datenprogrammierung auf einer Reihe verschiedener Prozessoren mit unterschiedlichen Graden von Gleitkomma-Pipelines ermöglicht wird. Der Vortrag befasst sich mit der Syntax zum Schreiben eines CUDA-Programms, der Thread-Hierarchie im CUDA-Programmiermodell, der CUDA-Speicherhierarchie, der Speicherkonsistenz und der Notwendigkeit, Speicher-Fence-Anweisungen zu verwenden, um die Reihenfolge von Speicheroperationen durchzusetzen, und die Bedeutung von Parallelität Programmierung in modernen Plattformen mit CPU und GPU. Abschließend diskutiert der Redner OpenCL, ein pragmatischeres und portableres Programmiermodell, das von Organisationen wie Chronos standardisiert wurde und die Zusammenarbeit zwischen verschiedenen Hardware- und Softwareanbietern wie Apple beinhaltet.

Der Sprecher im Video geht auf die Unterschiede zwischen den Programmiersprachen CUDA und OpenCL ein. Er stellt fest, dass beide Sprachen Ähnlichkeiten aufweisen, aber CUDA eine schönere Syntax hat und aufgrund seines ausgereiften Software-Stacks und seiner industriellen Akzeptanz weiter verbreitet ist. Im Gegensatz dazu zielt OpenCL auf Portabilität ab, bietet jedoch möglicherweise keine Leistungsportabilität, was sich auf seine Akzeptanz auswirken könnte. OpenCL ist jedoch ein Industriestandard, der von mehreren Unternehmen unterstützt wird. Darüber hinaus spricht der Referent über die Methodik zur Programmierung einer CPU vs. GPU und die Verwendung von Jacket, das Matlab umschließt und auf GPUs ausführt. Der Redner schließt mit einer Diskussion darüber, wie sich das Programm jedes Jahr auf der Grundlage des Feedbacks der Teilnehmer ändert, und ermutigt die Teilnehmer, das par lab zu besuchen.

  • 00:00:00 In diesem Abschnitt stellt sich der Referent vor und skizziert die Agenda für den Vortrag über GPGPU-Berechnung, wobei der Schwerpunkt hauptsächlich auf CUDA und einschließlich OpenCL liegt. Er gibt einen kurzen Überblick über GPU-Hardware und ihre Entwicklung von spezialisierten, nicht programmierbaren Einheiten für Grafiken zu leistungsfähigeren und flexibleren programmierbaren Einheiten mit der Einführung von CUDA und OpenCL. Das CUDA-Programmiermodell zielt darauf ab, GPU-Hardware zugänglicher und inhärent skalierbar zu machen, wodurch eine parallele Datenprogrammierung auf einer Reihe verschiedener Prozessoren mit unterschiedlichen Graden von Gleitkomma-Pipelines ermöglicht wird.

  • 00:05:00 In diesem Abschnitt erläutert der Redner das Ziel, SIMD-Hardware Allzweckprogrammierern zugänglich zu machen, was es erfordert, viele unabhängige Berechnungsblöcke so auszudrücken, dass eine Skalierbarkeit möglich ist. Der Referent vertieft sich in die Syntax zum Schreiben eines CUDA-Programms, das den Zugriff auf die Hardware der GPU und die Verwendung einer Multiple-Instruction-Multiple-Data-Thread-Abstraktion beinhaltet, die in Sindi auf der eigentlichen GPU ausgeführt wird. Die CUDA-Mem-Kopien werden als grundlegende Art der Kommunikation zwischen dem Host und dem Gerät hervorgehoben, und der Redner merkt an, dass die Kommunikation über die PCI-Express-Verbindung im System läuft, die relativ langsam ist, was es notwendig macht, die Datenübertragungen für eine optimale Übertragung zu minimieren Leistung. Außerdem wird ein kurzer Überblick über Vektorberechnungen gegeben.

  • 00:10:00 In diesem Abschnitt erklärt das Video, wie Standard-C++-Code für die Vektoraddition in ein paralleles CUDA-Programm geändert wird. Durch das Hinzufügen von Tags wird das Programm für die Ausführung auf der GPU kompiliert, und Threads verwenden Block- und Thread-Indizes, um zu bestimmen, an welchem Element des Arrays jeder Thread arbeiten soll. Das Video stellt auch fest, dass es relativ einfach ist, einfache CUDA-Programme zum Laufen zu bringen, aber die Optimierung der Leistung erfordert zusätzlichen Aufwand. Darüber hinaus bietet das Video einen Überblick über die CUDA-Softwareumgebung, die Thread-Hierarchie im CUDA-Programmiermodell und die GPU-Architektur, die aus Streaming-Multiprozessoren besteht.

  • 00:15:00 In diesem Abschnitt des Videos erläutert der Sprecher die Struktur der Grids und Thread-Blöcke, die parallel auf der GPU ausgeführt werden. Ein Grid ist ein Satz von bis zu 32 Thread-Blöcken, und jeder Thread-Block kann bis zu 1.000 CUDA-Threads ausführen. Jeder CUDA-Thread ist ein leichter, unabhängiger Ausführungskontext mit eigenem Programmstatus, der von jeder Adresse im GPU-DRAM geladen werden kann. Zusätzlich bilden Gruppen von 32 CUDA-Threads einen Warp, der im Lockstep ausgeführt wird und für Speicherzugriffe mit hoher Bandbreite entscheidend ist. Der Referent erklärt, dass Warps ein Detail zur Leistungsoptimierung sind, aber sie sind wichtig, um die Effizienz der Ausführungshardware zu maximieren.

  • 00:20:00 In diesem Abschnitt erläutert der Referent die grundlegenden Bausteine zum Schreiben von Code für NVIDIA-GPUs mit CUDA. Ein Thread-Block ist wie ein virtualisierter Multithread-Kern, der die Anzahl der CUDA-Threads, Register und L1-Cache, auf die er Zugriff hat, basierend auf der angegebenen Datengröße dynamisch konfigurieren kann. Ein Thread-Block enthält typischerweise eine datenparallele Aufgabe mit moderater Granularität, und alle Threads innerhalb des Blocks teilen sich denselben Blockindex-Identifizierer. Die Threads innerhalb eines Blocks können sich über barriereähnliche Intrinsic synchronisieren oder über schnellen gemeinsam genutzten Speicher auf dem Chip kommunizieren. Ein Gitter ist ein Satz von Fadenblöcken, und alle Fadenblöcke innerhalb eines Gitters haben denselben Eintrittspunkt, der sich nur in der Blockindexnummer unterscheidet. Das Programm muss für jede Verschachtelung der Blockausführung gültig sein, und es ist eine gute Idee, viele Threadblöcke pro Grid zu haben, um die gesamte GPU zu belegen. Die höchste Ebene der Thread-Hierarchie ist der Stream, der optional, aber für die gleichzeitige Ausführung mehrerer Kernel-Funktionen erforderlich ist.

  • 00:25:00 In diesem Abschnitt erörtert der Redner die CUDA-Speicherhierarchie, beginnend mit dem lokalen Speicher pro Thread, der als Sicherungsspeicher für die Registerdatei fungiert. Jeder CUDA-Thread hat privaten Zugriff auf eine konfigurierbare Anzahl von Registern, die zur Kompilierzeit angegeben werden, wobei sich das Speichersystem am Thread-Programmiermodell ausrichtet. Es gibt auch Scratchpad-Speicher, der entweder als 16 Kilobyte L1-Cache und 48 Kilobyte softwareverwaltetes Scratchpad oder umgekehrt verwendet werden kann und beim Aufruf des Kernels dynamisch konfiguriert werden kann. Der globale Speicher ist viel teurer als On-Chip-Speicher, mit einer über hundertfachen Latenz in Bezug auf die Anzahl der Zyklen. Die Register und On-Chip-Speicher halten den Zustand des Programms, während der globale Speicher den dauerhaften Zustand hält.

  • 00:30:00 In diesem Abschnitt geht der Referent auf die Speicherhierarchie von GPUs und CPUs ein. Die GPUs haben insgesamt eine höhere Bandbreite zu den L1-Caches im Vergleich zum globalen DRAM, wobei eine GPU in Modder-Größe etwa 100 Gigabyte pro Sekunde Zugriff auf den DRAM hat. Darüber hinaus gibt es andere Komponenten der Speicherhierarchie, die gelegentlich nützlich sind, wie der 64-Kilobyte-Konstantspeicher und der CUDA-Texturspeicher. Es können mehrere GPUs verwendet werden, wobei jede ihren eigenen unabhängigen globalen Speicher hat, der vom CPU-Speicher getrennt ist. Der wichtigste Aspekt der CUDA-Speicherhierarchie ist die Kommunikation innerhalb eines Thread-Blocks unter Verwendung des schnellen gemeinsam genutzten Onship-Speichers, was die Verwendung der Sync-Threads-Funktion erfordert, um die Threads innerhalb eines Thread-Blocks zu synchronisieren.

  • 00:35:00 In diesem Abschnitt stellt der Dozent ein Code-Snippet bereit, das eine Matrix mithilfe von Shared Memory transponiert, was entscheidend ist, um wesentlich mehr Parallelität als Speicherbandbreite auszudrücken. Während gemeinsam genutzte Variablen statisch über Tags am Anfang und am Ende deklariert werden können, können ganze Arrays zugewiesen werden und dynamisch mit extern über Integer-Indizes. Notizblöcke und synchrone Threads sind für fast die gesamte Kommunikation innerhalb eines Threadblocks unerlässlich, mit Ausnahme von Daten, die zwischen Threads geteilt werden. Der Zugriff auf den gemeinsam genutzten Speicher kann zu Bankkonflikten führen, die die Leistung ernsthaft beeinträchtigen können. Dieses Problem kann durch Verschachteln von Zeigern gemildert werden, so dass auf eine Bank zugegriffen werden kann, ohne dass irgendeine Zeitverzögerung verursacht wird. Abschließend spricht der Dozent von atomaren Speicheroperationen, die zwar kostspielig sind, aber Benutzern die Möglichkeit geben, von allen Threads in einem Programm auf denselben Speicherplatz zuzugreifen.

  • 00:40:00 In diesem Abschnitt erörtert der Sprecher die Speicherkonsistenz und die Notwendigkeit, Speicher-Fence-Anweisungen zu verwenden, um die Reihenfolge der Speicheroperationen durchzusetzen. Die Hardware synchronisiert automatisch Zugriffe von mehreren Threads, aber wenn der Programmierer keine Memory-Fence-Anweisungen verwendet, werden einige Ergänzungen möglicherweise nicht wirksam. Der Referent erklärt auch, wie bestimmte Operationen wie Exchange und Compare and Swap nützlich sind, um Spinlocks zu implementieren. Sie warnen davor, dass nicht davon ausgegangen werden kann, dass Speicherzugriffe global in der gleichen Reihenfolge erscheinen, in der sie ausgeführt wurden, da das Speichersystem eine hohe Leistung erzielt. Abschließend geht der Redner darauf ein, wie CUDA funktional fehlerverzeihend gestaltet ist, aber die Hardwareimplementierung entscheidend ist, um Leistung zu erzielen.

  • 00:45:00 In diesem Abschnitt erläutert der Referent das Konzept von Thread-Blöcken, die einem einzelnen Streaming-Multiprozessor entsprechen, und wie sie Zugriff auf mehrere Speicherressourcen wie Registerdateien, L1-Cache, Befehls-Cache und Textureinheiten haben . Ein Grid, das mehrere Thread-Blöcke umfasst, kann mehrere Streaming-Multiprozessoren auf einer GPU nutzen, und häufig reicht ein Grid aus, um die gesamte GPU zu sättigen. In Szenarien, in denen die Grids jedoch nicht groß genug sind, müssen mehrere Streams mehrere Grids parallel ausführen, um die gesamte GPU abzudecken. Um die Ausführungslatenzen einer Funktionseinheit und PCI-Express-Übertragungen zu verbergen, schlägt der Redner vor, dass mehrere Warps innerhalb desselben Thread-Blocks unabhängig voneinander ausgeführt werden, während gemeinsam genutzter Speicher und L1-Cache aktiv verwendet werden. Da die Speicherauslastung die Leistungsoptimierung dominiert, ist es wichtig, jedes aus dem Speicher geladene Byte mindestens zehn- bis zwanzigmal wiederzuverwenden, um die Leistung zu optimieren, und der Referent bietet weitere Anleitungen zur Verbesserung der Speicherauslastung.

  • 00:50:00 In diesem Abschnitt des Videos erörtert der Sprecher die Bedeutung der parallelen Programmierung in modernen Plattformen mit CPU, GPU und anderen Prozessoren. Er erklärt, dass jedes Programm alle Rechenressourcen nutzen sollte, die es benötigt, und dass die Welt in vielerlei Hinsicht heterogener wird. Er betont auch die Notwendigkeit eines Industriestandards für den Zugriff auf parallele Hardware zum Schreiben wartbarer paralleler Software und Programmierumgebungen auf höherer Ebene in SDKs zum Schreiben von parallelem Code. Außerdem erwähnt er die verschiedenen gescheiterten Programmiersprachen und dass Programme sich nicht darauf konzentrieren sollten, schön zu sein, sondern vielmehr darauf, ein gutes Programmiermodell zu finden. Der Redner spricht auch über OpenCL und erklärt, dass es versucht, nicht schön zu sein, und eine Alternative zu CUDA bietet.

  • 00:55:00 In diesem Abschnitt erörtert der Referent die Bedeutung von Pragmatismus und Portabilität bei Programmiermodellen für GPUs, da diese auf einer Vielzahl von Hardware laufen können und eine lange Lebensdauer der Software haben müssen. Dies stellt ein Problem für CUDA dar, das nur auf Nvidias Hardware läuft und sehr spezifisch und typisiert ist, was es für einige schwierig macht, es zu übernehmen. OpenCL hingegen ist ein pragmatischeres und portableres Programmiermodell, das von Organisationen wie Chronos standardisiert wurde und die Zusammenarbeit zwischen verschiedenen Hardware- und Softwareanbietern wie Apple beinhaltet. Die High-Level-Ansicht von OpenCL ähnelt CUDA in Bezug auf die Modellierung der Plattform und verwendet Befehlswarteschlangen, Arbeitselemente und ein ähnliches Speichermodell. Die Syntax für OpenCL ist jedoch viel komplexer und hat Hunderte von verschiedenen Funktionen für verschiedene Operationen. Das Vektoradditionsbeispiel wird erneut mit OpenCL-Code für die Kernelfunktion präsentiert, die das Entfernen der for-Schleife, das Hinzufügen eines Kernel-Tags und zusätzliche Tags zu Zeigern umfasst.

  • 01:00:00 In diesem Abschnitt erörtert der Referent die Unterschiede zwischen CUDA und OpenCL, die es Benutzern ermöglichen, verschiedene Arten von Hardware zu programmieren. Obwohl sie ähnliche Syntaxen aufweisen, bietet CUDA einen ausgereifteren Software-Stack und eine größere industrielle Akzeptanz, was zu einer breiteren Palette von Anwendungen führt. Auf der anderen Seite zielt OpenCL auf Portabilität ab, bietet jedoch möglicherweise keine Leistungsportabilität, was seine Einführung behindern könnte, wenn es nicht angesprochen wird. Dennoch ist OpenCL ein Industriestandard und wird von mehreren Unternehmen unterstützt, was Entwicklern Vertrauen in ihre Investition in seine Software gibt. Obwohl OpenCL ein Rivale für CUDA ist, unterstützt Nvidia es immer noch, und der Redner stellt klar, dass Nvidia möglicherweise keinen optimierten Code für OpenCL produziert.

  • 01:05:00 In diesem Abschnitt spricht der Referent über die Gemeinsamkeiten und Unterschiede zwischen den Programmiersprachen OpenCL und CUDA. Während beide Ähnlichkeiten aufweisen, bietet die Programmiersprache CUDA eine schönere Syntax, und es ist nicht erforderlich, die OpenCL-API zu kennen, um sie zu verwenden. Der Hauptgrund, warum die Compiler unterschiedlich sind, ist völlig pragmatisch, da NVIDIA sich entschieden hat, seinen OpenCL-Compiler nicht als Open Source zu machen. Die Methode zum Programmieren einer CPU vs. GPU besteht darin, auf die GPU abzuzielen und die gesamte Parallelisierung innerhalb eines Thread-Blocks zu beseitigen, einen Thread-Block in einen P-Thread oder einen Openmp-Thread umzuwandeln, der auf einem einzelnen CPU-Kern ausgeführt wird, und die Warps zuzuordnen SSE-Anweisungen. Der Redner spricht auch über Jacket, das Matlab verpackt und auf GPUs ausführt, obwohl es schwer zu sagen ist, wie viel Prozent ein Programm wie Jacket das volle Potenzial von CUDA ausschöpfen kann.

  • 01:10:00 In diesem Abschnitt erläutert der Referent, wie er das Programm jedes Jahr basierend auf dem Feedback der Teilnehmer ändert. Sie planen, ein Formular zu versenden, in dem gefragt wird, was den Teilnehmern gefallen hat, was nicht und was verbessert werden könnte. Es wird ein Panel eingerichtet, in dem Redner zusammenkommen, um lockere Diskussionen und Debatten auf der Bühne zu führen. Die Teilnehmer haben auch darum gebeten, das par lab zu sehen, daher werden sie ermutigt, den Raum selbst zu besuchen und zu sehen. Abschließend bedankt sich der Referent bei allen und wünscht ihnen ein gutes Restsemester.
 

Lernen bei Lambert Labs: Was ist OpenCL?



Was ist OpenCL?

In diesem Video über OpenCL stellt der Moderator Grafikverarbeitungseinheiten (GPUs) und ihre Verwendung in der Grafikprogrammierung vor, bevor er erklärt, wie sie für allgemeine Datenverarbeitung verwendet werden können. OpenCL wird dann als eine API vorgestellt, die es Entwicklern ermöglicht, herstellerspezifische Optimierungen zu erreichen und gleichzeitig plattformunabhängig zu sein, wobei der Redner die Bedeutung des Aufgabendesigns hervorhebt, um eine optimale GPU-Leistung zu erreichen. Die Synchronisierung in OpenCL wird erklärt, und ein GPU-Beispielprogramm wird in einer C-ähnlichen Sprache vorgestellt. Der Referent demonstriert auch, wie OpenCL die Berechnung erheblich beschleunigen kann, und gibt Ratschläge für die Arbeit mit GPUs.

  • 00:00:00 In diesem Abschnitt erklärt der Moderator, wofür Grafikprozessoren (GPUs) traditionell verwendet werden, nämlich Grafikprogrammierung wie das Rendern von Bildern in Echtzeit oder in vorgerenderten Anwendungen, die spezialisierte und hochleistungsfähige Hardware erfordern. Die Allzweck-GPU-Programmierung wird als Verwendung einer Grafikkarte für andere Aufgaben als Grafiken diskutiert, die sehr rechenintensiv sind und eine hohe Leistung erfordern. OpenCL wird dann als eine API eingeführt, die eine gemeinsame Schnittstelle für alle herstellerspezifischen Frameworks und Implementierungen bereitstellt, wodurch es möglich ist, weiterhin herstellerspezifische Optimierungen zu erhalten und gleichzeitig plattformunabhängig zu sein, was nützlich ist, da GPUs hoch spezialisierte und plattformabhängige Teile sind Hardware.

  • 00:05:00 In diesem Abschnitt des Videos erläutert der Sprecher die Funktionen von Aufgaben, die sich gut für die GPU-Optimierung eignen. Es ist wichtig, Aufgaben in kleinere Teilaufgaben zu unterteilen, die gleichzeitig in verschiedenen Threads ausgeführt werden können. Die Unteraufgaben sollten in Form und Zusammensetzung nahezu identisch sein, um auf mehreren Threads ausgeführt zu werden. Die Tasks müssen hinsichtlich der Synchronisierung voneinander unabhängig sein, da eine arbeitsgruppenübergreifende Synchronisierung nicht erforderlich ist. Das Video betont, dass je mehr Teilaufgaben voneinander abweichen, desto schlechter die Leistung wird und die CPU möglicherweise schneller ausgelastet wird. Um die GPU-Verarbeitungsleistung optimal nutzen zu können, müssen Aufgaben daher sorgfältig entworfen und optimiert werden.

  • 00:10:00 In diesem Abschnitt erklärt der Referent die Hauptmethode der Synchronisierung in OpenCL, nämlich die Sperrfunktion. Diese Funktion fungiert als Kontrollpunkt, den alle Threads erreichen müssen, bevor einer von ihnen fortfahren kann. Die Barrierefunktion ist zwar nicht besonders leistungsfähig, aber dennoch entscheidend, um sicherzustellen, dass alle Threads im richtigen Moment synchronisiert werden. Anschließend stellt der Referent ein GPU-Beispielprogramm vor, das in einer C-ähnlichen Sprache geschrieben ist, und erläutert die verschiedenen Parameter und die Logik des Codes. Abschließend führt der Referent einen Benchmark-Test mit einem Programm durch, das die ersten Millionen Quadratzahlen mit Python und OpenCL berechnet.

  • 00:15:00 In diesem Abschnitt bespricht der Sprecher sein Python-Skript, das ein Array von jeweils einer Million Zahlen und Quadraten verwendet. Anschließend untersuchen sie die Multi-Processing-Bibliothek in Python und erstellen einen Thread-Pool der Größe fünf, stellen jedoch fest, dass die parallele Ausführung die Berechnung tatsächlich verlangsamt. Schließlich zeigen sie ein OpenCL-Beispiel mit einer C-Kernel-Funktion, die als Zeichenfolge im Programmspeicher gespeichert ist, und gehen den erforderlichen Boilerplate-Code durch, um die Kernel-Funktion auszuführen. Die Ausführung des OpenCL-Beispiels dauert eine Millisekunde, eine deutliche Verbesserung gegenüber den vorherigen Python-Implementierungen.

  • 00:20:00 In diesem Abschnitt erklärt der Redner, dass die GPU-Programmierung einen Engpass im Code erheblich beschleunigen kann, indem die benötigte Zeit von 160 Millisekunden auf etwa eine Millisekunde reduziert wird, was einer 100-fachen Beschleunigung entspricht. Diese Art der Beschleunigung kann einen großen Unterschied machen, und zwei Größenordnungen können einen Engpass im Code "machen oder brechen". Die beste Möglichkeit für Entwickler, mit GPUs zu arbeiten, besteht darin, Zugriff auf eine lokale GPU zu haben, anstatt auf Remote-Computern zu arbeiten, obwohl Google Cloud Zugriff auf GPUs in der Cloud bietet. OpenCL ist unabhängig von unterschiedlicher GPU-Hardware, sodass es von Entwicklern unabhängig von ihrer GPU-Hardware verwendet werden kann. Entwickler müssen jedoch sorgfältig entwerfen, wie sie Probleme angehen, um das Beste aus der GPU herauszuholen, da die Teilaufgabenfunktion explizit sein muss, also müssen Teilaufgaben sorgfältig entworfen werden.
 

Beschleunigtes maschinelles Lernen mit OpenCL



Beschleunigtes maschinelles Lernen mit OpenCL

Im Webinar „Beschleunigtes maschinelles Lernen mit OpenCL“ diskutieren Referenten die Optimierungen, die an OpenCL für maschinelle Lernanwendungen vorgenommen werden können. Einer der Redner beschreibt, wie sie OpenCL und Assemblierung auf Intel-GPUs unter Verwendung der Open-Source-Bibliothek OneDNN verglichen haben. Sie konzentrieren sich auf die Optimierung für Intel-Hardware, bieten jedoch Schnittstellen für andere Hardware und unterstützen mehrere Datentypen und -formate. Die Gruppe diskutiert auch die Herausforderungen bei der Optimierung von Arbeitsabläufen für maschinelles Lernen mit OpenCL und die Integration von OpenCL in gängige Frameworks für maschinelles Lernen. Darüber hinaus stellen sie fest, dass die Konsolidierung der OpenCL-Nutzung über verschiedene Frameworks hinweg möglicherweise überfällig ist. Abschließend erörtern die Referenten die Leistungsvorteile der Verwendung der ML-Erweiterung von Qualcomm, insbesondere für bestimmte Schlüsseloperatoren wie Faltung, die in Bildverarbeitungsanwendungen wichtig ist.

Im Video „Beschleunigtes maschinelles Lernen mit OpenCL“ sprachen die Diskussionsteilnehmer über die verschiedenen Anwendungsfälle, in denen maschinelles Lernen eingesetzt werden kann, einschließlich Computerfotografie und Verarbeitung natürlicher Sprache. Sie betonten die Notwendigkeit, die Workloads des maschinellen Lernens zu optimieren und auf der Grundlage von Forschungsergebnissen zu skalieren. Darüber hinaus identifizierten die Diskussionsteilnehmer Sprache als bedeutenden Wachstumsbereich für fortschrittliche Benutzerschnittstellen mit maschinellem Lernen. Die Sitzung endete damit, dass sie sich und dem Publikum für ihre Beteiligung an der Diskussion dankten und die Teilnehmer daran erinnerten, Feedback durch die Umfrage zu geben.

  • 00:00:00 In diesem Abschnitt des Webinars gibt Neil Trevitt, Präsident der Chronos Group, einen kurzen Überblick über das Chronos Machine Learning Forum, ein offenes Forum, das die kontinuierliche Kommunikation zwischen der Chronos-Community und der Hardware für maschinelles Lernen fördern soll Software-Communities. Trevitt stellt fest, dass OpenCL auf dem Markt für maschinelles Lernen und Inferenz bereits weit verbreitet ist und dass viele neuere Erweiterungen von OpenCL für maschinelles Lernen und die Beschleunigung von Inferenzen relevant sind. Das Forum für maschinelles Lernen ist eine Gelegenheit für Entwickler, Beiträge zu leisten, und für Chronos, Updates und Roadmap-Informationen der breiteren Community vorzustellen.

  • 00:05:00 In diesem Abschnitt erläutert der Referent, ein KI-Algorithmus-Ingenieur bei Intel, seine Arbeit zum Vergleich von OpenCL und Assemblierung auf Intel-GPUs zur Optimierung für Workloads für maschinelles Lernen mithilfe der Open-Source-Bibliothek OneDNN. Er erklärt, dass sich ihr Team auf die Optimierung für Intel-Hardware konzentriert, aber auch Schnittstellen für andere Hardware bereitstellt und mehrere Datentypen und -formate unterstützt. Sie verwenden eine auf Just-in-Time-Kompilierung basierende Architektur, um basierend auf dem Problem und der Hardware eine optimale Implementierung auszuwählen, und sie optimieren sowohl kommende als auch bestehende integrierte GPUs. Anschließend diskutiert er die Ergebnisse ihres Vergleichs und die Probleme, auf die sie gestoßen sind, und führt sie zu ihren Entscheidungen zur Optimierung.

  • 00:10:00 In diesem Abschnitt erläutert der Sprecher, wie die GPU aufgeteilt ist und wie die Vektor-Engine und die Matrix-Engine die Hauptberechnung durchführen. Der Referent erklärt, wie sie für Faltungen und Datenumordnung optimieren und wie sie Untergruppen und Erweiterungen für die Intel-Hardware verwenden. Sie erwähnen, dass es Pläne gibt, einen einfacheren Zugriff zu ermöglichen, indem Erweiterungen zu sprv und Sichel hinzugefügt werden. Sie diskutieren auch ihre Assembly-Seite der Dinge, indem sie die ac plus-Bibliothek für die Assembly-Generierung auf Intel-GPUs verwenden. Abschließend sprechen sie über die erheblichen Beschleunigungen, die sie auf OpenCL durch Optimierung erreichen konnten.

  • 00:15:00 In diesem Abschnitt erörtert der Sprecher seine Analyse der OpenCL- und Engine-Implementierungen und stellt fest, dass die OpenCL-Implementierung unter bestimmten Bedingungen kürzere Leseanweisungen und zusätzliche Anweisungen ausgegeben hat. Sie weisen jedoch darauf hin, dass diese Probleme nicht grundlegend sind und gelöst werden können, indem mit dem Compiler-Team von Intel zusammengearbeitet wird, um die Implementierung zu ändern. Der Referent geht auch auf die Verwendung von Assembly ein, die nützlich ist, um Lücken in der Implementierung aufzudecken, aber schlecht für die Produktivität ist. Schließlich erwähnen sie die Einführung eines Assembly-Generators, der eine schnellere Codegenerierung mit der Möglichkeit ermöglichte, Optimierungstransformationen für das Problem anzugeben.

  • 00:20:00 In diesem Abschnitt erläutert der Redner, wie er seine Optimierungen effektiver zusammenstellen kann, indem er nur eine angegebene Transformation verwendet, wodurch eine Ausbreitung mehrerer Implementierungen vermieden werden kann. Als nächstes verlagert sich der Fokus auf Balaji Kalidas, der die Erweiterungen und Funktionen bespricht, die Qualcomm unterstützt, um beim beschleunigten maschinellen Lernen zu helfen, das seiner Meinung nach auf mobilen Geräten schnell wächst. Während GPUs eine beliebte Option bleiben, stellt der Redner fest, dass der Stromverbrauch, der Versand mit geringer Latenz und die Synchronisierung mit anderen Blöcken auf dem System-on-Chip allesamt wichtige Überlegungen sind, die angegangen werden müssen, um ein effizientes maschinelles Lernen auf mobilen Geräten sicherzustellen. Der Redner erwähnt Funktionen wie Zero-Copy-Import/Export von Daten und Import/Export von Android-Hardware-Puffer und DMA-Buff, um bei diesen Bedenken zu helfen.

  • 00:25:00 In diesem Abschnitt erörtert der Redner die ml-ops-Erweiterung von CL qcom, eine Qualcomm-Anbietererweiterung zur Beschleunigung des maschinellen Lernens auf ihren GPUs auf Operationsebene. Die Erweiterung verwendet so weit wie möglich vorhandene OpenCL-Konstrukte, einschließlich Befehlshinweise, Ereignisse und Puffer, und ist vollständig interoperabel mit anderen OpenCL-Kerneln. Einer der Hauptanwendungsfälle für die Erweiterung ist das Edge-Training, das Transfer Learning, Personalisierung und föderiertes Lernen ermöglicht, aber der primäre einschränkende Faktor für das Training am Edge ist der Speicherbedarf. Um dies anzugehen, erläutert der Referent den Tensor-Batch-Eins-Ansatz, der einen modifizierten Ansatz verwendet, um die Tensor-Batch-Größe auf eins zu halten und eine Reihe von Vorwärts- und Rückwärtsdurchläufen durchzuführen, bis der Batch abgeschlossen ist. Dieser Ansatz ermöglicht die gleichen Ergebnisse wie das Training mit einer größeren Stapelgröße, während der Speicherbedarf reduziert wird.

  • 00:30:00 In diesem Abschnitt erörtert der Referent mehrere OpenCL-Erweiterungen, die Aufgaben des maschinellen Lernens beschleunigen können. Die erste erwähnte Erweiterung ist eine 8-Bit-Dot-Produktanbietererweiterung, die bei der Implementierung von 8-Bit-quantisiertem DNNS erhebliche Leistungsvorteile bieten kann. Die nächste besprochene Erweiterung sind die „clq com recordable queues“, die die Aufzeichnung einer Folge von Kernel-Befehlen aus dem ND-Bereich ermöglichen, die mit einem speziellen Dispatch-Aufruf wiedergegeben werden können, was zu erheblichen Verbesserungen des CPU-Energieverbrauchs und der Dispatch-Latenz führt, was entscheidend ist in Anwendungsfällen für maschinelles Lernen im Streaming-Modus. Andere Erweiterungen wie Nullkopie, Untergruppenoperationen, Gleitkommaatomarisierung, verallgemeinertes Bild aus Puffer und Befehlspufferaufzeichnung und -wiedergabe sind ebenfalls nützlich für maschinelles Lernen und sind als Qualcomm-Erweiterungen verfügbar oder werden von Chronos ausgeliefert.

  • 00:35:00 es ist effizienter, eine größere Charge von Kerneln zu haben, die alle auf einmal eingereicht werden können, als sie einzeln einzureichen. Hier kommen beschreibbare Warteschlangen ins Spiel, da sie die Aufzeichnung und Vorverarbeitung einer großen Menge von Kernels ermöglichen, wobei sich zwischen jeder Instanz nur ein oder zwei Argumente ändern. Dies reduziert den Arbeitsaufwand für die Implementierung erheblich und spart CPU-Leistung. Darüber hinaus trägt es dazu bei, eine maximale GPU-Auslastung sicherzustellen und Leerlaufzeiten zwischen Versandvorgängen zu minimieren. Dies ist besonders wichtig für maschinelle Lernmodelle, bei denen Hunderte von Kerneln nacheinander ausgeführt werden müssen. Insgesamt sind beschreibbare Warteschlangen eine wertvolle Erweiterung zur Verbesserung der Effizienz der maschinellen Lernbeschleunigung mit OpenCL.

  • 00:40:00 In diesem Abschnitt diskutiert die Gruppe die Herausforderungen bei der Optimierung von Arbeitsabläufen für maschinelles Lernen mit OpenCL, einschließlich der Bestimmung des optimalen Zeitpunkts und der optimalen Größe der Stapelverarbeitung sowie des Spülens. Sie erwähnen, dass Tools wie Carbon Queues helfen können, diese Probleme zu lösen. Das Problem, dass die Kompilierzeiten ein großes Hindernis bei OpenCL sind, wird ebenfalls diskutiert, aber es ist kein einfach zu lösendes Problem. Die Gruppe schlägt die Verwendung von Spezialisierungskonstanten auf OpenCL-Ebene vor, um möglicherweise die Anzahl der generierten Kernel zu reduzieren, aber die Implementierung erfordert viel Arbeit. Sie diskutieren auch die potenzielle Verwendung von LLVM zur Leistungsoptimierung, weisen jedoch darauf hin, dass es derzeit langsame Kompilierzeiten als großes Problem hat.

  • 00:45:00 In diesem Abschnitt des Transkripts erörtern die Referenten die Herausforderungen beim Kompilieren von Anwendungen für maschinelles Lernen zur Laufzeit und die Verwendung vorkompilierter Binärdateien. Sie gehen auch auf die potenziellen Lösungen ein, die MLIR, eine mehrstufige Lösung, bietet, und wie sie im Vergleich zur Beschleunigung auf Diagrammebene abschneidet. Die Redner sind sich einig, dass die vom Anbieter bereitgestellte Erweiterung für einige wichtige Metabefehle verwendet werden könnte, während ein Graph-Compiler oder das Schreiben eigener Kernel für alles andere verwendet werden könnte, wodurch das Beste aus beiden Welten geboten wird.

  • 00:50:00 In diesem Abschnitt des Videos diskutieren die Referenten die Integration von OpenCL in gängige Frameworks für maschinelles Lernen, insbesondere auf Mobilgeräten. Sie erwähnen, dass es bereits eine Reihe von Open-Source-Frameworks gibt, die OpenCL verwenden, und dass TensorFlow Lite bereits über ein OpenCL-Backend verfügt, das gut läuft. Sie stellen jedoch fest, dass Leistung und Leistungsübertragbarkeit bei der Integration von OpenCL in generische Frameworks eine Herausforderung bleiben, da möglicherweise verschiedene Anbieter dazu beitragen müssen, die Leistung mit einer generischen Implementierung aufrechtzuerhalten. Sie schlagen auch vor, dass die Konsolidierung der OpenCL-Nutzung über verschiedene Frameworks hinweg überfällig sein könnte.

  • 00:55:00 In diesem Abschnitt erklärt der Redner, dass die Verwendung der ML-Erweiterung von Qualcomm im Vergleich zur reinen Verwendung von TVM oder Tensorflow Lite einen erheblichen Leistungsvorteil bietet. Der Nutzen hängt davon ab, wie viel Aufwand der Entwickler darauf verwendet, seinen eigenen Kernel zu schreiben und ihn für GPUs zu optimieren. Es gibt auch einen klaren Vorteil für bestimmte Schlüsseloperatoren, wie z. B. Faltung. Der Referent erwartet, durch die Beschleunigung dieser Schlüsselbetreiber in der Zukunft einen weiteren Mehrwert zu bieten. Das Panel diskutiert auch die Anwendungsbereiche, die die Nachfrage nach Beschleunigung des maschinellen Lernens antreiben, wobei die Bildverarbeitung ein dominierender Bereich ist.

  • 01:00:00 In diesem Abschnitt des Videos diskutierten die Diskussionsteilnehmer die Anwendungsbereiche für maschinelles Lernen, wie Computerfotografie und Verarbeitung natürlicher Sprache. Sie sprachen auch über die Herausforderungen bei der Optimierung der Workloads für maschinelles Lernen und die Notwendigkeit, auf der Grundlage von Forschungsergebnissen zu skalieren. Darüber hinaus wiesen die Diskussionsteilnehmer darauf hin, dass fortschrittliche Benutzerschnittstellen, die maschinelles Lernen verwenden, ein bedeutender Wachstumsbereich sein werden, und Sprache ist ein Teil davon. Schließlich endete die Sitzung, und die Diskussionsteilnehmer dankten einander und dem Publikum für ihre Teilnahme an der Diskussion, und der Moderator erinnerte die Teilnehmer daran, eine Umfrage auszufüllen, um Feedback zu erhalten.
 

Mandelbulber v2 OpenCL „Fast Engine“ 4K-Test

Mandelbulber v2 OpenCL „Fast Engine“ 4K-Test

Dies ist der Test zum Rendern von Fluganimationen mit Mandelbulber v2 mit teilweise implementierter OpenCL-Rendering-Engine. Der Grund dieses Tests war, die Stabilität der Anwendung bei langem Rendering zu überprüfen und wie sich das Rendering verhält, wenn die Kamera sehr nahe an der Oberfläche ist. Da der OpenCL-Kernelcode nur mit Gleitkommazahlen mit einfacher Genauigkeit ausgeführt wird, ist es nicht möglich, tiefe Zooms von 3D-Fraktalen durchzuführen. Um diese Animation in 4K-Auflösung zu rendern, dauerte es auf nVidia GTX 1050 nur 9 Stunden.

 

Mandelbox-Flug OpenCL



Mandelbox-Flug OpenCL

Dies ist ein Testrendering des Mandelbox-Fraktals, das mit Mandelbulber v2 OpenCL Alpha-Version gerendert wurde.

 

[3D FRAKTAL] Prophezeiung (4K)


[3D FRAKTAL] Prophezeiung (4K)

In 4K von Mandelbulb3D gerendert.

1...345678910
Neuer Kommentar
Grund der Beschwerde: