OpenHMPP

OpenHMPP (HMPP[1] Für hybride multicore -parallele Programmierung) - Programmierstandard für Heterogenes Computer. Basierend auf einer Reihe von Compiler -Direktiven ist Standard ein Programmiermodell, das für die Handlung entwickelt wurde Hardware Beschleuniger ohne die Komplexität mit dem mit GPU -Programmierung. Dieser auf Direktiven basierende Ansatz wurde implementiert, da sie eine lose Beziehung zwischen einem Anwendungscode und der Verwendung eines Hardware Accelerator (HWA) ermöglichen.

Einführung

Das auf OpenHMPP-Basis basierende Programmiermodell bietet eine Syntax, um Berechnungen auf Hardware-Beschleunigern abzuleiten und die Datenbewegung zum/vom Hardwarespeicher zu optimieren.

Das Modell basiert auf Arbeiten, die von CAPS (Compiler und Architektur für eingebettete und superscalar -Prozessoren) initialisiert wurden, ein gemeinsames Projekt von INRIA, CNRS, das Universität Rennes 1 und die Insa von Rennes.

OpenHMPP -Konzept

OpenHMPP basiert auf dem Konzept der Codelets, Funktionen, die auf HWAs aus der Ferne ausgeführt werden können.

Das OpenHMPP -Codelet -Konzept

Ein Codelet hat die folgenden Eigenschaften:

  1. Es ist ein reine Funktion.
    • Es enthält nicht statisch oder flüchtig Variable Deklarationen oder beziehen sich auf globale Variablen, außer wenn diese von einer HMPP -Richtlinie „Bewohner“ deklariert wurden
    • Es enthält keine Funktionsaufrufe mit einem unsichtbaren Körper (der nicht eingeführt werden kann). Dies beinhaltet die Verwendung von Bibliotheken und Systemfunktionen wie Malloc, Printf, ...
    • Jeder Funktionsaufruf muss sich auf eine statische reine Funktion beziehen (keine Funktionszeiger).
  2. Es gibt keinen Wert zurück (void -Funktion in C oder eine Unterroutine in Forran).
  3. Die Anzahl der Argumente sollte festgelegt werden (d. H. Es kann nicht a sein Variadische Funktion wie in stdarg.h in c).
  4. Es ist nicht rekursiv.
  5. Es wird angenommen Aliasing (Computing) und Zeiger -Aliasing).
  6. Es enthält keine Callsites -Direktiven (d. H. RPC zu einem anderen Codelet) oder anderen HMPP -Richtlinien.

Diese Eigenschaften stellen sicher, dass ein Codelet RPC Kann von einer HWA remote ausgeführt werden. Dieser RPC und seine zugehörigen Datenübertragungen können asynchron sein.

Codelet RPCs

HMPP liefert synchrones und asynchrones RPC. Die Implementierung des asynchronen Betriebs ist hardwareabhängig.

Synchron gegen asynchrones RPC

HMPP -Speichermodell

HMPP berücksichtigt zwei Adressräume: den Host -Prozessor und den HWA -Speicher.

HMPPP -Speichermodell

Richtlinienkonzept

Die OpenHMPP-Direktiven können als „Meta-Information“ im Anwendungsquellcode hinzugefügt werden. Sie sind sichere Meta-Information, d. H. Sie ändern das ursprüngliche Codeverhalten nicht. Sie adressieren die Remote -Ausführung (RPC) einer Funktion sowie die Datenübertragungen zum/aus dem HWA -Speicher.

In der folgenden Tabelle werden die OpenHMPP -Richtlinien vorgestellt. OpenHMPP -Richtlinien erfüllen unterschiedliche Bedürfnisse: Einige von ihnen sind Deklarationen gewidmet und andere sind der Verwaltung der Ausführung gewidmet.

Steuerflussanweisungen Richtlinien für das Datenmanagement
Erklärungen Codelet
Gruppe
Bewohner
Karte
MAPBYNAME
Betriebsrichtlinien Callsite
synchronisieren
Region
zuweisen
Veröffentlichung
Fortgeschrittene Ladung
Delegierter

Konzept der Richtlinie

Einer der grundlegenden Punkte des HMPP -Ansatzes ist das Konzept der Richtlinien und der damit verbundenen Etiketten, die es ermöglicht, eine kohärente Struktur auf eine ganze Reihe von Richtlinien aufzudecken, die in einer Anwendung verbreitet werden.

Es gibt zwei Arten von Etiketten:

  • Eine, die einem Codelet assoziiert ist. Im Allgemeinen beschränken sich die Richtlinien, die diese Art von Etiketten tragen, auf die Verwaltung von nur einem Codelet (als eigenständiges Codelet im Rest des Dokuments bezeichnet, um es von der Gruppe der Codelets zu unterscheiden).
  • Eine, die einer Gruppe von Codeletten verbunden ist. Diese Bezeichnungen werden wie folgt festgestellt: "<LabelOfGroup>", wobei "LabelOfGroup" ein vom Benutzer angegebener Name ist. Im Allgemeinen beziehen sich die Richtlinien, die ein Etikett dieser Art haben, auf die gesamte Gruppe. Das Konzept der Gruppe ist einer Klasse von Problemen vorbehalten, für die ein spezifisches Management der Daten während der gesamten Anwendung erforderlich ist, um Leistung zu erhalten.

OpenHMPP -Direktiven Syntax

Um die Notationen zu vereinfachen, Reguläre Ausdrücke wird verwendet, um die Syntax der HMPP -Richtlinien zu beschreiben.

Die folgende Farbkonvention wird zur Beschreibung der Syntax -Richtlinien verwendet:

  • Reservierte HMPP -Schlüsselwörter sind in grün;
  • Grammatikelemente, die in HMPP -Schlüsselwörtern abgelehnt werden können rot;
  • Die Variablen des Benutzers bleiben schwarz.

Allgemeine Syntax

Die allgemeine Syntax von OpenHMPP -Richtlinien lautet:

  • Für c Sprache:
#PRAGMA HMPP <GRP_Label> [codelet_label]? Richtlinie_Type [,Richtlinie_Parameters]* [&] 
  • Für die Fortran -Sprache:
! $ hmpp <GRP_Label> [codelet_label]? Richtlinie_Type [,Richtlinie_Parameters]* [&] 

Wo:

  • : ist eine eindeutige Kennung, die eine Gruppe von Codeletten nennt. In Fällen, in denen keine Gruppen in der Anwendung definiert sind, kann dieses Etikett einfach verpassen. Der Name des Rechtsetikels muss dieser Grammatik folgen: [A-Z, A-Z, _] [A-Z, A-Z, 0-9, _]*. Beachten Sie, dass die "<>" -Scharaktere zur Syntax gehören und für diese Art von Etikett obligatorisch sind.
  • codelet_label: ist ein eindeutiger Kennung, der ein Codelet nennt. Der Name des Rechtsetikels muss dieser Grammatik folgen: [A-Z, A-Z, _] [A-Z, A-Z, 0-9, _]*
  • Richtlinie: Ist der Name der Richtlinie;
  • Richtlinie_Parameters: Bezeichnet einige Parameter, die der Richtlinie zugeordnet sind. Diese Parameter können von unterschiedlichen Arten sein und entweder einige Argumente angeben, die der Richtlinie entweder eine Ausführungsweise angegeben haben (zum Beispiel asynchron gegen Synchron).
  • [&]: Ist ein Charakter, der die Richtlinie in der nächsten Zeile fortsetzt (gleich für C und Forran).

Richtlinienparameter

Die mit einer Richtlinie verbundenen Parameter können unterschiedliche Typen haben. Im Folgenden finden Sie die in OpenHMPP definierten Richtlinienparameter:

  • Version = major.minor [.micro]: Gibt die Version der HMPP -Richtlinien an, die vom Präprozessor berücksichtigt werden soll.
  • args [arg_items] .size = {dimSize [, dimSize]*}: Gibt die Größe eines nicht -skalaren Parameters an (ein Array).
  • args [arg_items] .io = [in | out | in Out]: Gibt an, dass die angegebenen Funktionsargumente entweder Eingabe, Ausgabe oder beides sind. Uneingeschränkt sind uneingeschränkte Argumente Eingaben.
  • cond = "expr" ": Gibt eine Ausführungsbedingung als boolean C- oder FORTRAN -Ausdruck an, der wahr sein muss, um die Ausführung der Gruppe oder Codelets zu starten.
  • target = target_name [: target_name]*: Gibt an, welche Ziele in der angegebenen Reihenfolge verwendet werden sollen.
  • asynchron: Gibt an, dass die Codelet -Ausführung nicht blockiert (Standard ist synchron).
  • args [] .advancedload = true: Gibt an, dass die angegebenen Parameter vorinstalliert sind. Nur in oder In -Out -Parametern können vorinstalliert werden.
  • args [arg_items] .noupdate = true: Diese Eigenschaft gibt an, dass die Daten bereits auf der HWA verfügbar sind und dass keine Übertragung erforderlich ist. Wenn diese Eigenschaft festgelegt ist, erfolgt keine Übertragung für das betrachtete Argument
  • args [] .Addr = "": ist ein Ausdruck, der die zu hochgeladene Datenadresse angibt.
  • args [] .Const = true: Zeigt an, dass das Argument nur einmal hochgeladen werden soll.

OpenHMPP -Richtlinien

Richtlinien für die Erklärung und Ausführung eines Codelet

A Codelet Die Richtlinie erklärt eine Berechnung, die auf einem Hardware -Beschleuniger remote ausgeführt wird. Für die Codelet Richtlinie:

  • Das Codelet -Etikett ist obligatorisch und muss in der Anwendung eindeutig sein
  • Das Gruppenetikett ist nicht erforderlich, wenn keine Gruppe definiert ist.
  • Die Codelet -Anweisung wird kurz vor der Funktionserklärung eingefügt.

Die Syntax der Richtlinie lautet:

#PRAGMA HMPP <GRP_Label> codelet_label Codelet                              [, Ausführung = major.minor [.micro]?]? [, args [arg_items] .io =[[in|aus|in Out]]* [, args [arg_items] .SIZE = {dimsize [, dimsize]*}]* [, args [arg_items] .Const = true]* [, cond = "expr"] [, Ziel =target_name[:target_name]*]

Es können mehr als eine Codelet -Anweisung zu einer Funktion hinzugefügt werden, um unterschiedliche Verwendungen oder unterschiedliche Ausführungskontexte anzugeben. Es kann jedoch nur eine Codelet -Richtlinie für ein bestimmtes Aufruf -Site -Etikett geben.

Das Callsite Die Richtlinie gibt an, wie die Verwendung eines Codelet an einem bestimmten Punkt im Programm verwendet wird.

Die Syntax der Richtlinie lautet:

#PRAGMA HMPP <GRP_Label> codelet_label Callsite                      [asynchron]? [, args [arg_items] .SIZE = {dimsize [, dimsize]*}]* [, args [arg_items] .Advancedload =[[Stimmt|FALSCH]]* [, args [arg_items] .Addr = "Expr"]* [, args [arg_items] .noupdate = true]*

Hier wird ein Beispiel gezeigt:

 / * Deklaration des Codelet */  #PRAGMA HMPP Simple1 Codelet, args [outv] .io = inout, target = cuda  statisch Leere Matvec(int sn, int sm, schweben Inv[sm], schweben Inm[sn][sm], schweben *outv) {   int i, j;   zum (i = 0 ; i < sm ; i++) {   schweben Temperatur = outv[i];   zum (j = 0 ; j < sn ; j++) {   Temperatur += Inv[j] * Inm[i][ j];   }   outv[i] = Temperatur;   }      int hauptsächlich(int argc, verkohlen **argv) {   int n;   ........      / * Codelet -Verwendung */   #PRAGMA HMPP Simple1 CallSite, Args [outv] .size = {n}   Matvec(n, m, MyCinc, Inm, mein outv);   ........   } 

In einigen Fällen ist eine spezifische Verwaltung der Daten in der gesamten Anwendung erforderlich (CPU/GPU -Datenbewegungsoptimierung, freigegebene Variablen ...).

Das Gruppe Die Richtlinie ermöglicht die Erklärung einer Gruppe von Codeletten. Die in dieser Direktive definierten Parameter werden auf alle der Gruppe angewendet. Die Syntax der Richtlinie lautet:

#PRAGMA HMPP <GRP_Label> Gruppe                            [, Version = .[.]?]?                            [, Ziel = target_name[:target_name]*]]? [, cond = "Expr]?

Datenübertragungsanweisungen zur Optimierung der Kommunikationsaufwand

Bei der Verwendung eines HWA ist der Haupttipp häufig die Datenübertragungen zwischen HWA und dem Hauptprozessor.
Um den Kommunikationsaufwand einzuschränken, können Datenübertragungen mit aufeinanderfolgenden Ausführungen desselben Codelets überlappt werden, indem die asynchrone Eigenschaft der HWA verwendet wird.

  • Richtlinie zuweisen

Das zuweisen Die Richtlinie sperrt die HWA und verteilt die erforderliche Menge an Speicher.

#PRAGMA HMPP <GRP_Label> Zuweisen [, args [arg_items] .SIZE = {dimsize [, dimsize]*}]*
  • Release -Richtlinie

Das Veröffentlichung Die Richtlinie gibt an, wann die HWA für eine Gruppe oder ein eigenständiges Codelet freigegeben werden soll.

#PRAGMA HMPP <GRP_Label> Freigabe 
  • Erweiterte Ladungsrichtlinie

Das Fortgeschrittene Ladung Die Richtlinie setzt Daten vor der Remoteausführung des Codelet vor.

#PRAGMA HMPP <GRP_Label> [codelet_label]? Fortgeschrittene Ladung  , args [arg_items]                   [, args [arg_items] .SIZE = {dimsize [, dimsize]*}]* [, args [arg_items] .Addr = "Expr"]* [, args [arg_items] .Section = {[subcript_triplet,]+}]* [,asynchron] 
  • DelegatedStore -Richtlinie

Das Delegierter Die Richtlinie ist eine Synchronisationsbarriere, um auf eine asynchrone Codelet -Ausführung zu warten und die Ergebnisse herunterzuladen.

#PRAGMA HMPP <GRP_Label> [codelet_label]? Delegierter   , args [arg_items]                 [, args [arg_items] .Addr = "Expr"]* [, args [arg_items] .Section = {[subcript_triplet,]+}]*
  • Asynchrone Berechnungen

Das synchronisieren Die Richtlinie gibt an, bis zur Fertigstellung einer asynchronen Callsit -Ausführung zu warten. Für die Synchronisierungsrichtlinie ist das Codelet -Etikett immer obligatorisch und das Gruppenetikett ist erforderlich, wenn das Codelet zu einer Gruppe gehört.

#PRAGMA HMPP <GRP_Label> codelet_label synchronisieren 
  • Beispiel

Im folgenden Beispiel werden die Geräteinitialisierung, die Speicherzuweisung und das Hochladen der Eingabedaten nur einmal außerhalb der Schleife und nicht in jeder Iteration der Schleife durchgeführt.

Das synchronisieren Durch die Richtlinie warten Sie, bis die asynchrone Ausführung des Codelet -Codelet abgeschlossen ist, bevor eine andere Iteration gestartet wird. Endlich, das Delegierter Richtlinie außerhalb der Schleife lädt das SGEMM -Ergebnis hoch.

 int hauptsächlich(int argc, verkohlen **argv) {    #PRAGMA HMPP SGEMM -Zuordnung, args [vin1; vin2; vout] .size = {Größe, Größe}  #PRAGMA HMPP SGEMM Advancedload, Args [vin1; vin2; vout], args [M, N, K, Alpha, Beta]     zum ( j = 0 ; j < 2 ; j ++) {   #PRAGMA HMPP SGEMM Callsite, asynchron, args [vin1; vin2; vout].   SGEMM (Größe, Größe, Größe, Alpha, vin1, vin2, Beta, VOUT);   #PRAGMA HMPP SGEMM Synchronisieren  }    #PRAGMA HMPP SGEMM DelegatedStore, Args [Vout]  #PRAGMA HMPP SGEMM -Veröffentlichung 

Daten zwischen Codelets teilen

Diese Richtlinien kartieren alle Argumente, die den angegebenen Namen für die gesamte Gruppe teilen.

Die Typen und Dimensionen aller zugeordneten Argumente müssen identisch sein.

Das Karte Die Richtlinie ordnet mehrere Argumente auf dem Gerät ab.

#PRAGMA HMPP <GRP_Label> Karte, args [arg_items] 

Diese Richtlinie ist ziemlich ähnlich wie die Karte Richtlinie mit der Ausnahme, dass die zu kartierenden Argumente direkt mit ihrem Namen angegeben sind. Das MAPBYNAME Die Richtlinie entspricht mehreren Karte Richtlinien.

#PRAGMA HMPP <GRP_Label> MAPBYNAME [,VariobLename]+

Globale Variable

Das Bewohner Die Richtlinie erklärt einige Variablen innerhalb einer Gruppe als global. Diese Variablen können dann direkt von jedem zur Gruppe gehörenden Codelet -Codelet zugegriffen werden. Diese Richtlinie gilt für die Erklärungserklärung, die sie im Quellcode befolgt.

Die Syntax dieser Richtlinie lautet:

#PRAGMA HMPP <GRP_Label> Bewohner                 [, args [::var_name] .io =[[in|aus|in Out]]* [, args [::var_name] .SIZE = {dimsize [, dimsize]*}]* [, args [::var_name] .Addr = "Expr"]* [, args [::var_name] .Const = true]*

Die Notation :: var_name mit dem Präfix ::, Zeigt die als Bewohner deklarierte Variable einer Anwendung an.

Beschleunigung von Regionen

Eine Region ist eine Verschmelzung der Codelet/Callsite -Richtlinien. Ziel ist es, die Umstrukturierung der Code zu vermeiden, um das Codelet zu erstellen. Daher alle verfügbaren Attribute für Codelet oder Callsite Richtlinien können auf verwendet werden Regionen Richtlinien.

In C -Sprache:

#PRAGMA HMPP [<<<<<<<<<<<<<<<<<<<<<<<<<<<Meine Gruppe>] [Etikett] Region                                     [, args [arg_items] .io =[[in|aus|in Out]]* [, cond = "Expr"]<                            [, args [arg_items] .Const = true]* [, Ziel =target_name[:target_name]*] [, args [arg_items] .SIZE = {schwach [,Dimsize]*}]* [, args [arg_items] .Advancedload =[[Stimmt|FALSCH]]* [, args [arg_items] .Addr = "Expr"]* [, args [arg_items] .noupdate = true]* [asynchron]? [, privat = [arg_items]]* {C Blockanweisungen}

Implementierungen

Der OpenHMPP Open Standard basiert auf HMPP Version 2.3 (Mai 2009, Caps Entreprise).

Das auf OpenHMPP-basierende Programmiermodell ist implementiert in:

  • CAPS Compiler, Caps Unternehmer Compiler für Hybrid Computing
  • Pathscale Enzo Compiler Suite (Unterstützung des Nvidia -GPUs)

OpenHMPP wird von verwendet von HPC Schauspieler[wer?] In Öl & Gas, Energie, Fertigung, Finanzen, Bildung und Forschung.

Siehe auch

Verweise

  1. ^ Dolbeau, Romain; Bihan, Stéphane; Bodin, François (4. Oktober 2007). HMPP: Eine hybride multi-core-parallele Programmierumgebung (PDF). Workshop zur Allzweckverarbeitung in Grafikverarbeitungseinheiten. Archiviert von das Original (PDF) am 16. Januar 2014. Abgerufen 14. Januar 2014.