Startseite>Programmierbezogen>Delphi-Quellcode
Herunterladen

［日本語］

Opencl

Parallele Computing mit OpenCL auf GPUs und CPUs.

■ 1. LUX.GPU.OpenCL Library

TOpenCL : Singleton von TCLSystem
┃
TCLSystem : System
┗ TCLPlatfos : Plattformliste
┗ TCLPlatfo : Plattform
┣ TCLExtenss : Erweiterungsliste
┣ TCLDevices : Geräteliste
┃ ┗ ┗ TCLDevice ： Gerät
┗ TCLContexs : Kontextliste
┗ TCLContex : Kontext
┣ TCLQueuers : Befehlsqueueliste
┃ ┗ TCLQueuer : Befehlswarteschlange
┣ TCLArgumes : Argumentliste
┃ ┣ TCLBuffer : Puffer
┃ ┣ TCLImager : Bild
┃ ┗ TCLSamplr : Sampler
┣ TCLLibrars : Bibliotheksliste
┃ ┗ TCLLibrar : Bibliothek
┗ TCLExecuts : Ausführbare Programmliste
┗ TCLExecut : Ausführbares Programm
┣ TCLBuildrs : Buildliste
┃ ┗ TCLBuildr ： bauen
┗ TCLKernels : Kernelliste
┗ TCLKernel : Kernel
┗ TCLParames : Parameterliste
┗ TCLParame : Parameter

■ 2. Verwendung

Die TOpenCL -Klasse ist ein Singleton der TCLSystem -Klasse. Die TCLSystem -Klasse erkennt automatisch alle auf dem Host -Computer vorhandenen Computergeräte .

⬤ 2.1. Plattform

Das " Plattform " -Objekt ( TCLPlatfo ) repräsentiert die Umgebung, die jeder Geräteanbieter bereitstellt. Die TCLSystem -Klasse erkennt automatisch alle Plattform S und listet sie in der Eigenschaft Platfos[] auf.

Object Pascal 

TOpenCL.Platfos.Count :Integer    // Number of all platforms
TOpenCL.Platfos[*]    :TCLPlatfo  // Array of all platforms

Die TCLPlatfo -Klasse bietet Informationen zu einer bestimmten Plattform als Eigenschaften.

Object Pascal 

_Platfo := TOpenCL.Platfos[ 0 ];  // Selecting a specific platform

_Platfo.Handle        :T_cl_platform_id  // Pointer
_Platfo.Profile       :String            // Profile
_Platfo.Version       :String            // Version
_Platfo. Name          :String            // Name
_Platfo.Vendor        :String            // Vendor Name
_Platfo.Extenss.Count :Integer           // Number of Extensions
_Platfo.Extenss[*]    :String            // Array of Extensions

⬤ 2.2. Gerät

Das " Geräte " -Objekt ( TCLDevice ) repräsentiert eine physische GPU oder CPU. Die TCLPlatfo -Klasse erkennt automatisch alle Geräteobjekte in einem bestimmten Plattformobjekt und zählt sie in der Eigenschaft der Devices[] auf.

Object Pascal 

_Platfo.Devices.Count :Integer    // Number of devices
_Platfo.Devices[*]    :TCLDevice  // Array of devices

Die TCLDevice -Klasse enthält detaillierte Informationen zu jedem bestimmten Gerät über seine Eigenschaften.

Object Pascal 

_Device := _Platfo.Devices[ 0 ];  // Selecting a specific device

_Device.Handle           :T_cl_device_id    // Pointer
_Device.DEVICE_TYPE      :T_cl_device_type  // Type
_Device.DEVICE_VENDOR_ID :T_cl_uint         // Vendor ID
_Device.DEVICE_NAME      :String            // Name
_Device.DEVICE_VENDOR    :String            // Vendor
_Device.DRIVER_VERSION   :String            // Driver Version
_Device.DEVICE_PROFILE   :String            // Profile
_Device.DEVICE_VERSION   :String            // Version

⬤ 2.3. Kontext

Das " Kontext " -Objekt ( TCLContex ) verwaltet eine Sammlung verwandter Daten und Programme. Die TCLContex -Klasse wird aus der TCLPlatfo -Klasse instanziiert.

Object Pascal 

_Contex := TCLContex.Create( _Platfo );

Die generierte TCLContex -Klasse ist in der Contexs[] -Sache der TCLPlatfo -Klasse registriert.

Object Pascal 

_Platfo.Contexs.Count :Integer    // Number of contexts
_Platfo.Contexs[*]    :TCLContex  // Array  of contexts
``

⬤ 2.4. Befehlswarteschlange

Das Objekt " Befehlswarteschlangen " ( TCLQueuer ) verwaltet die an das Gerät gesendeten Befehle. Mit anderen Worten, es dient als Brücke zwischen einem Kontext und einem Gerät . Die TCLQueuer -Klasse wird mit den Klassen TCLContex und TCLDevice als Argumente erstellt.

Object Pascal 

_Queuer := TCLQueuer.Create( _Contex, _Device );
  { or }
_Queuer := _Contex.Queuers[ _Device ];

Die TCLContex -Klasse registriert das TCLQueuer -Objekt in der Eigenschaft Queuers[] .

Object Pascal 

_Contex.Queuers.Count :Integer    // Number of command queue
_Contex.Queuers[*]    :TCLQueuer  // Array  of command queue

Beachten Sie, dass Kontext und Gerät auf den verschiedenen Plattformen keine Befehlswarteschlange generieren können.

Object Pascal 

P0 := TOpenCL.Platfos[ 0 ];
P1 := TOpenCL.Platfos[ 1 ];
P2 := TOpenCL.Platfos[ 2 ];

D00 := P0.Devices[ 0 ];  D01 := P0.Devices[ 1 ];  D02 := P0.Devices[ 2 ]; 
D10 := P1.Devices[ 0 ];
D20 := P2.Devices[ 0 ];

C0 := TCLContex.Create( P0 ); 
C1 := TCLContex.Create( P1 ); 
C2 := TCLContex.Create( P2 );

Q00 := TCLQueuer.Create( C0, D00 );  // OK
Q01 := TCLQueuer.Create( C0, D01 );  // OK
Q02 := TCLQueuer.Create( C0, D02 );  // OK

Q10 := TCLQueuer.Create( C1, D00 );  // Error
Q11 := TCLQueuer.Create( C1, D01 );  // Error
Q12 := TCLQueuer.Create( C1, D02 );  // Error

Q20 := TCLQueuer.Create( C2, D00 );  // Error
Q21 := TCLQueuer.Create( C2, D10 );  // Error
Q22 := TCLQueuer.Create( C2, D20 );  // OK

⬤ 2.5. Argument

TCLArgume
┣ TCLMemory
┃ ┣ TCLBuffer
┃ ┗ TCLImager
┗ TCLSamplr

▼ 2.5.1. Erinnerung

Das " Speicher " -Objekt ( TCLMemory ) speichert verschiedene Daten und teilt es mit dem Gerät . Die TCLMemory -Klasse wird aus den Klassen TCLContex und TCLQueuer erstellt. Die TCLMemory -Klasse ist abstrakt und leitet die TCLBuffer und TCLImager -Klassen ab.

▽ 2.5.1.1. Puffer

Die TCLBuffer -Klasse speichert ein Array eines "einfachen Typs" oder "Datensatztyp".

Wenn Sie ein Array des folgenden Strukturtyps an das Gerät senden möchten,

OpenCL C 

 typedef struct {
  int    A ;
  double B ;
} TItem ;

kernel void Main ( global TItem * Buffer ) {
  ･･･
}

Generieren Sie die TCLBuffer -Klasse wie folgt.

Object Pascal 

TItem = record
  A :Integer;
  B :Double;
end ;

_Buffer := TCLBuffer<TItem>.Create( _Contex, _Queuer );

Lesen und schreiben Sie Array -Daten über die Data . Die Array -Daten müssen " MAP PED" sein , um vor dem Lesen oder Schreiben mit dem Host zu synchronisieren, und um nach der Verwendung mit dem Gerät mit dem Gerät zu synchronisieren.

Object Pascal 

_Buffer.Count := 3 ;                          // Setting the number of elements
_Buffer.Data.Map;                            // Synchronize data with host
_Buffer.Data[ 0 ] := TItem.Create( 1 , 2.34 );  // Writing
_Buffer.Data[ 1 ] := TItem.Create( 5 , 6.78 );  // Writing
_Buffer.Data[ 2 ] := TItem.Create( 9 , 0.12 );  // Writing
_Buffer.Data.Unmap;                          // Synchronize data with Device

▽ 2.5.1.2. Bild

Das " Bild " -Objekt ( TCLImager ) speichert das Pixel -Array in 1D bis 3D. 3D -Voxeldaten werden ebenfalls als eine Art 3D -Bild angesehen. Die TCLImager -Klasse ist abstrakt und leitet verschiedene Klassen ab, abhängig vom Layout und der Bits des Farbkanals.

TCLImager
┣ TCLImager1D
┃ ┣ TCLImager1DxBGRAxUInt8
┃ ┣ TCLImager1DxBGRAxUFix8
┃ ┣ TCLImager1DxRGBAxUInt32
┃ ┗ TCLImager1DxRGBAxSFlo32
┣ TCLImager2D
┃ ┣ TCLImager2DxBGRAxUInt8
┃ ┣ TCLImager2DxBGRAxUFix8
┃ ┣ TCLImager2DxRGBAxUInt32
┃ ┗ TCLImager2DxRGBAxSFlo32
┗ TCLImager3D
┣ TCLImager3DxBGRAxUInt8
┣ TCLImager3DxBGRAxUFix8
┣ TCLImager3DxRGBAxUInt32
┗ TCLImager3DxRGBAxSFlo32

Der erste Teil des Klassennamens repräsentiert die Dimension eines Bildes.

  • Tclimager 1D x * x *
    • Dimension: 1D
  • Tclimager 2D x * x *
    • Dimension: 2D
  • Tclimager 3D x * x *
    • Dimension: 3D

Der zweite Teil des Klassennamens repräsentiert die Farbkanal -Reihenfolge eines Bildes.

  • Tclimager * x BGRA x *
    • Farbkanalbestellung: ｂｇ ｂｇ ｂｇ ｂｇ ＢＧＲＡ
  • Tclimager * x RGBA x *
    • Farbkanalbestellung: ： ＲＧＢＡ

Der dritte Teil des Klassennamens repräsentiert den Farbdatentyp eines Bildes.

  • Tclimager * x * x UInt8
    • Geräteseitiger Datentyp: uint8 @ opencl c
    • Host-Seite-Datentyp: UInt8 (Byte) @ delphi
  • Tclimager * x * x UFix8
    • Geräteseitiger Datentyp: float @ opencl c
    • Host-Seite-Datentyp: UInt8 (Byte) @ delphi
  • Tclimager * x * x UInt32
    • Geräteseitiger Datentyp: uint @ opencl c
    • Host-Seite-Datentyp: UInt32 (Cardinal) @ Delphi
  • Tclimager * x * x SFlo32
    • Geräteseitiger Datentyp: float @ opencl c
    • Host-Seite-Datentyp: Single @ delphi

Die Eigenschaft "countx"/"y"/"Z" legt die Anzahl der Pixel in der X/Y/Z -Richtung fest.

Object Pascal 

_Imager := TCLDevIma3DxBGRAxUInt8.Create( _Contex, _Queuer );
_Imager.CountX := 100 ;  // Number of pixels in the X direction
_Imager.CountY := 200 ;  // Number of pixels in the Y direction
_Imager.CountZ := 300 ;  // Number of pixels in the Z direction

▼ 2.5.2. Sampler

Das Sampler-Objekt ( TCLSamplr ) definiert die Interpolationsmethode, um die Pixelfarbe in realen Koordinaten zu erhalten.
Die TCLSamplr -Klasse wird mit der "Tcontex" -Klasse als Argument erzeugt.

Object Pascal 

_Samplr := TCLSamplr.Create( _Contex );

⬤ 2.6. Programm

Das " Programm " Objekt ( TCLProgra ) liest den Quellcode und kompiliert ihn in eine ausführbare Binärdatei. Die TCLProgra -Klasse wird mit der TCLContex -Klasse als Argument erstellt. Die TCLProgra -Klasse ist abstrakt und dient als Basisklasse für die TCLLibrar und TCLExecut -Klassen, abhängig vom Art des Quellcodes.

▼ 2.6.1. Bibliothek

Die TCLLibrar -Klasse ist ein Programm, das keine Funktionen zur direkten Ausführung enthält, wird als Bibliothekstyp bezeichnet.

Object Pascal 

_Librar := TCLLibrar.Create( _Contex );

_Librar.Source.LoadFromFile( ' Librar.cl ' );  // load Sourcecode

▼ 2.6.2. Ausführbar

Die TCLExecut -Klasse ist ein Programm, das Funktionen ( Kernel S) direkt ausführen.

Object Pascal 

_Execut := TCLExecut.Create( _Contex );

_Execut.Source.LoadFromFile( ' Execut.cl ' );  // load Sourcecode

⬤ 2.7. Bauen

Ein " Build " ( TCLBuildr ) ist eine "Aktion", die von einem Programm ausgeführt wird, wird jedoch ausdrücklich als Klasse in unserer Bibliothek dargestellt.

Object Pascal 

_Buildr := TCLBuildr.Create( _Execut, _Device );
  { or }
_Buildr := _Execut.Buildrs[ _Device ];
  { or }
_Buildr := _Execut.BuildTo( _Device );

Das Kernel -Objekt (siehe Kapitel 2.8.) Erstellt automatisch die TCLBuildr -Klasse zur Laufzeit. Sie können jedoch auf Kompilierungs- und Verknüpfungsfehler suchen, indem Sie ein TCLBuildr -Objekt erstellen, bevor Sie den Kernel ausführen.

Object Pascal 

_Buildr.Handle;  // Run build

_Buildr.CompileStatus :T_cl_build_status  // Compile status
_Buildr.CompileLog    :String             // Compile log
_Buildr.LinkStatus    :T_cl_build_status  // Link status
_Buildr.LinkLog       :String             // Link log

⬤ 2.8. Kernel

Das " Kernel " -Objekt ( TCLKernel ) stellt eine ausführbare Funktion in einem Programm dar.

OpenCL C 

 kernel void Main ( ･･･ ) {
  ･･･
}

Die TCLKernel -Klasse wird aus den TCLExecut und TCLQueuer -Objekten instanziiert.

Object Pascal 

_Kernel := TCLKernel.Create( _Execut, ' Main ' , _Queuer );
  { or }
_Kernel := _Execut.Kernels.Add( ' Main ' , _Queuer );

▼ 2.8.1. Parameter

Das Speicherobjekt ist über die Eigenschaft "Parames" der TCLKernel -Klasse mit dem Parameter im Quellcode verknüpft.

Object Pascal 

_Kernel.Parames[ ' Buffer ' ] := _Buffer;  // Connect to buffer
_Kernel.Parames[ ' Imager ' ] := _Imager;  // Connect to image
_Kernel.Parames[ ' Samplr ' ] := _Samplr;  // Connect to sampler

▼ 2.8.2. Schleifenzahl

Das OpenCL-Programm fährt wiederholt wie eine dreifache Schleife.

Object Pascal 

_Kernel.GloSizX := 100 ;  // Number of loops in X direction
_Kernel.GloSizY := 200 ;  // Number of loops in Y direction
_Kernel.GloSizZ := 300 ;  // Number of loops in Z direction

Sie können auch die minimalen und maximalen Schleifenindizes angeben.

Object Pascal 

_Kernel.GloMinX := 0 ;      // Start index in X direction
_Kernel.GloMinY := 0 ;      // Start index in Y direction
_Kernel.GloMinZ := 0 ;      // Start index in Z direction

_Kernel.GloMaxX := 100 - 1 ;  // End index in X direction
_Kernel.GloMaxY := 200 - 1 ;  // End index in Y direction
_Kernel.GloMaxZ := 300 - 1 ;  // End index in Z direction

▼ 2.8.3. Laufen

Object Pascal 

_Kernel.Run;  // Run

■ 3. Referenz

⬤ 3.1. Die Khronos Group Inc.

  • Khronos OpenCL Registry - Die Khronos Group Inc.
    • 3.0
      • Die OpenCL -Spezifikation
      • Die openCL -Spezifikation .pdf
      • Die OpenCL C -Spezifikation
      • Die OpenCL C -Spezifikation .pdf

⬤ 3.2. Github

  • Die Khronos -Gruppe
    • OpenCl-Lader
  • Delphi ide @ embarcadero
    https://www.embarcadero.com/jp/products/delphi/starter
Expandieren
Zusätzliche Informationen
Ähnliche Anwendungen
Empfohlen für Sie
Ähnliche Nachrichten Alle