OpenCL
1.0.0
［日本語］
Computación paralela con OpenCL en GPU y CPU.
LUX.GPU.OpenCL Biblioteca
TOpenCL: Singleton de TCLSYSTEM
┃
TCLSystem: Sistema
┗TCLPlatfos: Lista de plataformas
┗TCLPlatfo: plataforma
┣TCLExtenss: Lista de extensión
┣TCLDevices: Lista de dispositivos
┃ ┗TCLDevice： DISPOSITIVO
┗TCLContexs: Lista de contexto
┗TCLContex: contexto
┣TCLQueuers: Lista de colas de comandos
┃ ┗TCLQueuer： cola de comandos
┣TCLArgumes: Lista de argumentos
┃ ┣ ┣TCLBuffer： buffer
┃ ┣TCLImager： Imagen
┃ ┗TCLSamplr: muestreador
┣TCLLibrars: Lista de biblioteca
┃ ┗TCLLibrar： Biblioteca
┗TCLExecuts: Lista de programas ejecutables
┗TCLExecut: programa ejecutable
┣TCLBuildrs: Lista de compilación
┃ ┗ ┗TCLBuildr： Build
┗TCLKernels: lista de núcleos
┗TCLKernel: núcleo
┗TCLParames: Lista de parámetros
┗TCLParame: parámetro
La clase TOpenCL es un singleton de la clase TCLSystem . La clase TCLSystem detecta automáticamente todos los dispositivos informáticos presentes en la máquina host.
El objeto " Plataforma " ( TCLPlatfo ) representa el entorno proporcionado por cada proveedor de dispositivos. La clase TCLSystem detecta automáticamente todas las plataformas y las enumera en la propiedad Platfos[] .
Object PascalTOpenCL.Platfos.Count :Integer // Number of all platforms TOpenCL.Platfos[*] :TCLPlatfo // Array of all platforms
La clase TCLPlatfo proporciona información sobre una plataforma específica como propiedades.
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
El objeto " Dispositivo " ( TCLDevice ) representa una GPU o CPU física. La clase TCLPlatfo detecta automáticamente todos los objetos de dispositivo en un objeto de plataforma específico y los enumera en la propiedad Devices[] .
Object Pascal_Platfo.Devices.Count :Integer // Number of devices _Platfo.Devices[*] :TCLDevice // Array of devices
La clase TCLDevice proporciona información detallada sobre cada dispositivo específico a través de sus propiedades.
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
El objeto " contexto " ( TCLContex ) administra una colección de datos y programas relacionados. La clase TCLContex se instancia desde la clase TCLPlatfo .
Object Pascal_Contex := TCLContex.Create( _Platfo );
La clase TCLContex generada está registrada en la propiedad Contexs[] de la clase TCLPlatfo .
Object Pascal_Platfo.Contexs.Count :Integer // Number of contexts _Platfo.Contexs[*] :TCLContex // Array of contexts ``
El objeto " cola de comandos " ( TCLQueuer ) administra los comandos enviados al dispositivo. En otras palabras, sirve como un puente entre un contexto y un dispositivo . La clase TCLQueuer se crea con las clases TCLContex y TCLDevice como argumentos.
Object Pascal_Queuer := TCLQueuer.Create( _Contex, _Device ); { or } _Queuer := _Contex.Queuers[ _Device ];
La clase TCLContex registra el objeto TCLQueuer en la propiedad Queuers[] .
Object Pascal_Contex.Queuers.Count :Integer // Number of command queue _Contex.Queuers[*] :TCLQueuer // Array of command queue
Tenga en cuenta que el contexto y el dispositivo en las diferentes plataformas no pueden generar una cola de comando .
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
El objeto " Memoria " ( TCLMemory ) almacena varios datos y los comparte con el dispositivo . La clase TCLMemory se crea a partir de las clases TCLContex y TCLQueuer . La clase TCLMemory es abstracta y deriva las clases TCLBuffer y TCLImager .
La clase TCLBuffer almacena una matriz de cualquier "tipo simple" o "tipo de registro".
Si desea enviar una matriz del siguiente tipo de estructura al dispositivo,
OpenCL Ctypedef struct { int A ; double B ; } TItem ; kernel void Main ( global TItem * Buffer ) { ･･･ }
Genere la clase TCLBuffer de la siguiente manera.
Object PascalTItem = record A :Integer; B :Double; end ; _Buffer := TCLBuffer<TItem>.Create( _Contex, _Queuer );
Lea y escriba datos de matriz a través de la propiedad Data . Los datos de la matriz deben ser "PED de mapa " para sincronizar con el host antes de leer o escribir, y "PED UNMAP " para sincronizar con el dispositivo después de su uso.
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
El objeto " Imagen " ( TCLImager ) almacena la matriz de píxeles en 1D a 3D. Los datos de Voxel 3D también se consideran un tipo de imagen 3D. La clase TCLImager es abstracta y deriva varias clases dependiendo del diseño y los bits del canal de color.
TCLImager
┣TCLImager1D
┃ ┣TCLImager1DxBGRAxUInt8
┃ ┣TCLImager1DxBGRAxUFix8
┃ ┣TCLImager1DxRGBAxUInt32
┃ ┗ ┗TCLImager1DxRGBAxSFlo32
┣TCLImager2D
┃ ┣TCLImager2DxBGRAxUInt8
┃ ┣TCLImager2DxBGRAxUFix8
┃ ┣TCLImager2DxRGBAxUInt32
┃ ┗ ┗TCLImager2DxRGBAxSFlo32
┗TCLImager3D
┣TCLImager3DxBGRAxUInt8
┣TCLImager3DxBGRAxUFix8
┣TCLImager3DxRGBAxUInt32
┗TCLImager3DxRGBAxSFlo32
La primera parte del nombre de clase representa la dimensión de una imagen.
- Tclimager
1Dx*x*
- Dimensión:
1D- Tclimager
2Dx*x*
- Dimensión:
2D- Tclimager
3Dx*x*
- Dimensión:
3D
La segunda parte del nombre de clase representa el orden del canal de color de una imagen.
- Tclimager
*xBGRAx*
- Orden de canal de color:
ＢＧＲＡ- Tclimager
*xRGBAx*
- Orden de canal de color:
ＲＧＢＡ
La tercera parte del nombre de clase representa el tipo de datos de color de una imagen.
- Tclimager
*x*xUInt8
- Tipo de datos del lado del dispositivo:
uint8@ opencl c- Tipo de datos del lado del host:
UInt8 (Byte)@ delphi- TCLIMAGER
*X*XUFix8
- Tipo de datos del lado del dispositivo:
float@ opencl c- Tipo de datos del lado del host:
UInt8 (Byte)@ delphi- Tclimager
*x*xUInt32
- Tipo de datos del lado del dispositivo:
uint@ opencl c- Tipo de datos del lado del host:
UInt32 (Cardinal)@ delphi- TCLIMAGER
*X*XSFlo32
- Tipo de datos del lado del dispositivo:
float@ opencl c- Tipo de datos del lado del host:
Single@ delphi
La propiedad 'Countx'/'y'/'z' establece el número de píxeles en la dirección 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
El objeto Sampler ( TCLSamplr ) define el método de interpolación para obtener el color de píxeles en coordenadas de número real.
La clase TCLSamplr se genera con la clase 'TClContex' como argumento.
Object Pascal_Samplr := TCLSamplr.Create( _Contex );
El objeto " Programa " ( TCLProgra ) lee el código fuente y lo compila en un binario ejecutable. La clase TCLProgra se crea con la clase TCLContex como argumento. La clase TCLProgra es abstracta y sirve como la clase base para las clases TCLLibrar y TCLExecut , dependiendo del tipo de código fuente.
La clase TCLLibrar es un programa que no incluye funciones para ejecutar directamente se llama tipo de biblioteca.
Object Pascal_Librar := TCLLibrar.Create( _Contex ); _Librar.Source.LoadFromFile( ' Librar.cl ' ); // load Sourcecode
La clase TCLExecut es un programa que incluye funciones ( kernel s) para ejecutar directamente.
Object Pascal_Execut := TCLExecut.Create( _Contex ); _Execut.Source.LoadFromFile( ' Execut.cl ' ); // load Sourcecode
Una " construcción " ( TCLBuildr ) es una "acción" realizada por un programa , pero se representa explícitamente como una clase en nuestra biblioteca.
Object Pascal_Buildr := TCLBuildr.Create( _Execut, _Device ); { or } _Buildr := _Execut.Buildrs[ _Device ]; { or } _Buildr := _Execut.BuildTo( _Device );
El objeto del núcleo (ver Capítulo 2.8.) Crea automáticamente la clase TCLBuildr en tiempo de ejecución. Sin embargo, puede verificar si hay errores de compilación y vinculación creando un objeto TCLBuildr antes de ejecutar el núcleo.
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
El objeto " kernel " ( TCLKernel ) representa una función ejecutable en un programa.
OpenCL Ckernel void Main ( ･･･ ) { ･･･ }
La clase TCLKernel se instancia desde los objetos TCLExecut y TCLQueuer .
Object Pascal_Kernel := TCLKernel.Create( _Execut, ' Main ' , _Queuer ); { or } _Kernel := _Execut.Kernels.Add( ' Main ' , _Queuer );
El objeto de memoria está vinculado al parámetro en el código fuente a través de la propiedad "Parames" de la clase TCLKernel .
Object Pascal_Kernel.Parames[ ' Buffer ' ] := _Buffer; // Connect to buffer _Kernel.Parames[ ' Imager ' ] := _Imager; // Connect to image _Kernel.Parames[ ' Samplr ' ] := _Samplr; // Connect to sampler
El programa OpenCL se ejecuta repetidamente como una declaración de triple bucle.
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
También puede especificar los índices de bucle mínimo y máximo.
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
