OpenCL
1.0.0
［日本語］
Informatique parallèle avec OpenCL sur les GPU et les CPU.
LUX.GPU.OpenCL Library
TOpenCL: singleton de tclsystem
┃
TCLSystem： Système
┗TCLPlatfos: Liste des plateformes
┗TCLPlatfo: Platform
┣TCLExtenss: Liste d'extension
┣TCLDevices: Liste des périphériques
┃ ┗TCLDevice: Appareil
┗TCLContexs: Liste de contexte
┗TCLContex: Contexte
┣TCLQueuers: Liste des files d'attente de commande
┃ ┗TCLQueuer: Fitre de commande
┣TCLArgumes: Liste des arguments
┃ ┣TCLBuffer： tampon
┃ ┣TCLImager: Image
┃ ┗TCLSamplr: échantillonneur
┣TCLLibrars: Liste des bibliothèques
┃ ┗TCLLibrar: bibliothèque
┗TCLExecuts: Liste des programmes exécutables
┗TCLExecut: Programme exécutable
┣TCLBuildrs: Liste de construction
┃ ┗TCLBuildr：
┗TCLKernels: Liste du noyau
┗TCLKernel: noyau
┗TCLParames: Liste des paramètres
┗TCLParame： Paramètre
La classe TOpenCL est un singleton de la classe TCLSystem . La classe TCLSystem détecte automatiquement tous les appareils informatiques présents sur la machine hôte.
L'objet " Platform " ( TCLPlatfo ) représente l'environnement fourni par chaque fournisseur de périphériques. La classe TCLSystem détecte automatiquement toutes les plates-formes et les répertorie dans la propriété Platfos[] .
Object PascalTOpenCL.Platfos.Count :Integer // Number of all platforms TOpenCL.Platfos[*] :TCLPlatfo // Array of all platforms
La classe TCLPlatfo fournit des informations sur une plate-forme spécifique en tant que propriétés.
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
L'objet " Device " ( TCLDevice ) représente un GPU ou un processeur physique. La classe TCLPlatfo détecte automatiquement tous les objets de périphérique dans un objet de plate-forme spécifique et les énumère dans la propriété Devices[] .
Object Pascal_Platfo.Devices.Count :Integer // Number of devices _Platfo.Devices[*] :TCLDevice // Array of devices
La classe TCLDevice fournit des informations détaillées sur chaque appareil spécifique via ses propriétés.
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
L'objet " Context " ( TCLContex ) gère une collection de données et de programmes connexes. La classe TCLContex est instanciée à partir de la classe TCLPlatfo .
Object Pascal_Contex := TCLContex.Create( _Platfo );
La classe TCLContex générée est enregistrée dans la propriété Contexs[] de la classe TCLPlatfo .
Object Pascal_Platfo.Contexs.Count :Integer // Number of contexts _Platfo.Contexs[*] :TCLContex // Array of contexts ``
L'objet " Command Fitre " "( TCLQueuer ) gère les commandes envoyées à l'appareil. En d'autres termes, il sert de pont entre un contexte et un appareil . La classe TCLQueuer est créée avec les classes TCLContex et TCLDevice comme arguments.
Object Pascal_Queuer := TCLQueuer.Create( _Contex, _Device ); { or } _Queuer := _Contex.Queuers[ _Device ];
La classe TCLContex enregistre l'objet TCLQueuer dans la propriété Queuers[] .
Object Pascal_Contex.Queuers.Count :Integer // Number of command queue _Contex.Queuers[*] :TCLQueuer // Array of command queue
Notez que le contexte et le périphérique sur les différentes plates-formes ne peuvent pas générer de file d'attente de commandes .
Object PascalP0 := 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
TCLArgume
┣TCLMemory
┃ ┣TCLBuffer
┃ ┗TCLImager
┗TCLSamplr
L'objet " Memory " ( TCLMemory ) stocke diverses données et les partage avec l' appareil . La classe TCLMemory est créée à partir des classes TCLContex et TCLQueuer . La classe TCLMemory est abstraite et tire les classes TCLBuffer et TCLImager .
La classe TCLBuffer stocke un tableau de tout "type simple" ou "type d'enregistrement".
Si vous souhaitez envoyer un tableau du type de structure suivant à l'appareil,
OpenCL Ctypedef struct { int A ; double B ; } TItem ; kernel void Main ( global TItem * Buffer ) { ･･･ }
Générez la classe TCLBuffer comme suit.
Object PascalTItem = record A :Integer; B :Double; end ; _Buffer := TCLBuffer<TItem>.Create( _Contex, _Queuer );
Lisez et écrivez des données de tableau via la propriété Data . Les données du tableau doivent être " Map Ped" pour se synchroniser avec l'hôte avant de lire ou d'écrire, et " Unmap Ped" pour se synchroniser avec l'appareil après utilisation.
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
L'objet " Image " ( TCLImager ) stocke le tableau de pixels en 1D à 3D. Les données de voxel 3D sont également considérées comme un type d' image 3D. La classe TCLImager est abstraite et tire diverses classes en fonction de la disposition et des bits du canal de couleur.
TCLImager
┣TCLImager1D
┃ ┣TCLImager1DxBGRAxUInt8
┃ ┣TCLImager1DxBGRAxUFix8
┃ ┣TCLImager1DxRGBAxUInt32
┃ ┗TCLImager1DxRGBAxSFlo32
┣TCLImager2D
┃ ┣TCLImager2DxBGRAxUInt8
┃ ┣TCLImager2DxBGRAxUFix8
┃ ┣TCLImager2DxRGBAxUInt32
┃ ┗TCLImager2DxRGBAxSFlo32
┗TCLImager3D
┣TCLImager3DxBGRAxUInt8
┣TCLImager3DxBGRAxUFix8
┣TCLImager3DxRGBAxUInt32
┗TCLImager3DxRGBAxSFlo32
La première partie du nom de classe représente la dimension d'une image.
- Tclimager
1Dx*x*
- Dimension ：
1D- Tclimager
2Dx*x*
- Dimension:
2D- Tclimager
3Dx*x*
- Dimension ：
3D
La deuxième partie du nom de classe représente l'ordre du canal de couleur d'une image.
- Tclimager
*xBGRAx*
- Ordre de canal de couleur ：
ＢＧＲＡ- Tclimager
*xRGBAx*
- Ordre de canal de couleur ：
ＲＧＢＡ
La troisième partie du nom de classe représente le type de données de couleur d'une image.
- Tclimager
*x*xUInt8
- Type de données côté périphérique:
uint8@ opencl c- Type de données côté hôte:
UInt8 (Byte)@ delphi- Tclimager
*x*xUFix8
- Type de données côté périphérique ：
float@ opencl C- Type de données côté hôte:
UInt8 (Byte)@ delphi- Tclimager
*x*xUInt32
- Type de données côté périphérique:
uint@ opencl c- Type de données côté hôte ：
UInt32 (Cardinal)@ delphi- Tclimager
*x*xSFlo32
- Type de données côté périphérique ：
float@ opencl C- Type de données côté hôte ：
Single@ Delphi
La propriété 'countx' / 'y' / 'z' définit le nombre de pixels dans la direction x / y / z.
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
L'objet d'échantillonneur ( TCLSamplr ) définit la méthode d'interpolation pour obtenir la couleur du pixel dans les coordonnées du nombre réel.
La classe TCLSamplr est générée avec la classe 'TclContex' comme argument.
Object Pascal_Samplr := TCLSamplr.Create( _Contex );
L'objet " Program " ( TCLProgra ) lit le code source et le compile en un binaire exécutable. La classe TCLProgra est créée avec la classe TCLContex comme argument. La classe TCLProgra est abstraite et sert de classe de base pour les classes TCLLibrar et TCLExecut , selon le type de code source.
La classe TCLLibrar est un programme qui n'inclut pas les fonctions à exécuter directement est appelée type de bibliothèque.
Object Pascal_Librar := TCLLibrar.Create( _Contex ); _Librar.Source.LoadFromFile( ' Librar.cl ' ); // load Sourcecode
La classe TCLExecut est un programme qui comprend des fonctions ( noyaux ) à exécuter directement.
Object Pascal_Execut := TCLExecut.Create( _Contex ); _Execut.Source.LoadFromFile( ' Execut.cl ' ); // load Sourcecode
Un " build " ( TCLBuildr ) est une "action" effectuée par un programme , mais elle est explicitement représentée comme une classe dans notre bibliothèque.
Object Pascal_Buildr := TCLBuildr.Create( _Execut, _Device ); { or } _Buildr := _Execut.Buildrs[ _Device ]; { or } _Buildr := _Execut.BuildTo( _Device );
L'objet du noyau (voir chapitre 2.8.) Crée automatiquement la classe TCLBuildr à l'exécution. Cependant, vous pouvez vérifier les erreurs de compilation et de liaison en créant un objet TCLBuildr avant d'exécuter le noyau.
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
L'objet " Kernel " ( TCLKernel ) représente une fonction exécutable dans un programme.
OpenCL Ckernel void Main ( ･･･ ) { ･･･ }
La classe TCLKernel est instanciée à partir des objets TCLExecut et TCLQueuer .
Object Pascal_Kernel := TCLKernel.Create( _Execut, ' Main ' , _Queuer ); { or } _Kernel := _Execut.Kernels.Add( ' Main ' , _Queuer );
L'objet mémoire est lié au paramètre dans le code source via la propriété "Parames" de la classe TCLKernel .
Object Pascal_Kernel.Parames[ ' Buffer ' ] := _Buffer; // Connect to buffer _Kernel.Parames[ ' Imager ' ] := _Imager; // Connect to image _Kernel.Parames[ ' Samplr ' ] := _Samplr; // Connect to sampler
Le programme OpenCL s'exécute à plusieurs reprises comme une déclaration de boucle triple.
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
Vous pouvez également spécifier les indices de boucle minimale et maximale.
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
Object Pascal_Kernel.Run; // Run
