OpenCL
1.0.0
［日本語］
Computação paralela com OpenCL nas GPUs e CPUs.
LUX.GPU.OpenCL
TOpenCL: Singleton do TCLsystem
┃
TCLSystem: Sistema
┗TCLPlatfos: Lista de plataforma
┗TCLPlatfo: plataforma
┣TCLExtenss: Lista de extensão
┣TCLDevices： Lista de dispositivos
┃ ┗TCLDevice: dispositivo
┗TCLContexs: Lista de contexto
┗TCLContex: Contexto
┣TCLQueuers: Lista de filas de comando
┃ ┗TCLQueuer: Fila de comando
┣TCLArgumes： Lista de argumentos
┃ ┣TCLBuffer: buffer
┃ ┣TCLImager: imagem
┃ ┗TCLSamplr: amostrador
┣TCLLibrars: Lista de bibliotecas
┃ ┗TCLLibrar: Biblioteca
┗TCLExecuts: Lista de programas executáveis
┗TCLExecut: Programa executável
┣TCLBuildrs: Lista de construção
┃ ┗TCLBuildr: construção
┗TCLKernels: Lista de kernel
┗TCLKernel: kernel
┗TCLParames: Lista de parâmetros
┗TCLParame: Parâmetro
A classe TOpenCL é um singleton da classe TCLSystem . A classe TCLSystem detecta automaticamente todos os dispositivos de computação presentes na máquina host.
O objeto " plataforma " ( TCLPlatfo ) representa o ambiente fornecido por cada fornecedor de dispositivo. A classe TCLSystem detecta automaticamente todas as plataformas e os lista na propriedade Platfos[] .
Object PascalTOpenCL.Platfos.Count :Integer // Number of all platforms TOpenCL.Platfos[*] :TCLPlatfo // Array of all platforms
A classe TCLPlatfo fornece informações sobre uma plataforma específica como propriedades.
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
O objeto " dispositivo " ( TCLDevice ) representa uma GPU ou CPU física. A classe TCLPlatfo detecta automaticamente todos os objetos de dispositivo em um objeto de plataforma específico e os enumora na propriedade Devices[] .
Object Pascal_Platfo.Devices.Count :Integer // Number of devices _Platfo.Devices[*] :TCLDevice // Array of devices
A classe TCLDevice fornece informações detalhadas sobre cada dispositivo específico por meio de suas propriedades.
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
O objeto " contexto " ( TCLContex ) gerencia uma coleção de dados e programas relacionados. A classe TCLContex é instanciada da classe TCLPlatfo .
Object Pascal_Contex := TCLContex.Create( _Platfo );
A classe TCLContex gerada é registrada na propriedade Contexs[] da classe TCLPlatfo .
Object Pascal_Platfo.Contexs.Count :Integer // Number of contexts _Platfo.Contexs[*] :TCLContex // Array of contexts ``
O objeto " Fila de comando " ( TCLQueuer ) gerencia os comandos enviados ao dispositivo. Em outras palavras, serve como uma ponte entre um contexto e um dispositivo . A classe TCLQueuer é criada com as classes TCLContex e TCLDevice como argumentos.
Object Pascal_Queuer := TCLQueuer.Create( _Contex, _Device ); { or } _Queuer := _Contex.Queuers[ _Device ];
A classe TCLContex registra o objeto TCLQueuer na propriedade Queuers[] .
Object Pascal_Contex.Queuers.Count :Integer // Number of command queue _Contex.Queuers[*] :TCLQueuer // Array of command queue
Observe que o contexto e o dispositivo nas diferentes plataformas não podem gerar uma fila 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
O objeto " Memory " ( TCLMemory ) armazena vários dados e os compartilha com o dispositivo . A classe TCLMemory é criada a partir das classes TCLContex e TCLQueuer . A classe TCLMemory é abstrata e deriva as classes TCLBuffer e TCLImager .
A classe TCLBuffer armazena uma matriz de qualquer "tipo simples" ou "tipo de registro".
Se você deseja enviar uma matriz do seguinte tipo de estrutura para o dispositivo,
OpenCL Ctypedef struct { int A ; double B ; } TItem ; kernel void Main ( global TItem * Buffer ) { ･･･ }
Gere a classe TCLBuffer da seguinte maneira.
Object PascalTItem = record A :Integer; B :Double; end ; _Buffer := TCLBuffer<TItem>.Create( _Contex, _Queuer );
Leia e escreva dados da matriz através da propriedade Data . Os dados da matriz devem ser " map PED" para sincronizar com o host antes de ler ou escrever e " unmap ped" para sincronizar com o dispositivo após o 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
O objeto " Image " ( TCLImager ) armazena a matriz de pixels em 1D a 3D. Os dados do Voxel 3D também são considerados um tipo de imagem 3D. A classe TCLImager é abstrata e deriva várias classes, dependendo do layout e dos bits do canal de cores.
TCLImager
┣TCLImager1D
┃ ┣TCLImager1DxBGRAxUInt8
┃ ┣TCLImager1DxBGRAxUFix8
┃ ┣TCLImager1DxRGBAxUInt32
┃ ┗TCLImager1DxRGBAxSFlo32
┣TCLImager2D
┃ ┣TCLImager2DxBGRAxUInt8
┃ ┣TCLImager2DxBGRAxUFix8
┃ ┣TCLImager2DxRGBAxUInt32
┃ ┗TCLImager2DxRGBAxSFlo32
┗TCLImager3D
┣TCLImager3DxBGRAxUInt8
┣TCLImager3DxBGRAxUFix8
TCLImager3DxRGBAxUInt32
TCLImager3DxRGBAxSFlo32
A primeira parte do nome da classe representa a dimensão de uma imagem.
- Tclimager
1Dx*x*
- Dimensão:
1D- Tclimager
2Dx*x*
- Dimensão:
2D- Tclimager
3Dx*x*
- Dimensão:
3D
A segunda parte do nome da classe representa a ordem do canal colorido de uma imagem.
- Tclimager
*xBGRAx*
- Ordem de canal colorido:
ＢＧＲＡ- Tclimager
*xRGBAx*
- Ordem de canal colorido:
ＲＧＢＡ
A terceira parte do nome da classe representa o tipo de dados de uma imagem.
- Tclimager
*x*xUInt8
- Tipo de dados do lado do dispositivo ：
uint8@ opencl c- Tipo de dados do lado do hospedeiro ：
UInt8 (Byte)@ delphi- Tclimager
*x*xUFix8
- Tipo de dados do lado do dispositivo ：
float@ opencl c- Tipo de dados do lado do hospedeiro ：
UInt8 (Byte)@ delphi- Tclimager
*x*xUInt32
- Tipo de dados do lado do dispositivo ：
uint@ opencl c- Tipo de dados do lado do hospedeiro ：
UInt32 (Cardinal)@ delphi- Tclimager
*x*xSFlo32
- Tipo de dados do lado do dispositivo ：
float@ opencl c- Tipo de dados do lado do hospedeiro ：
Single@ delphi
A propriedade 'countx'/'y'/'z' define o número de pixels na direção 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
O objeto Sampler ( TCLSamplr ) define o método de interpolação para obter a cor do pixel em coordenadas do número real.
A classe TCLSamplr é gerada com a classe 'TclContex' como um argumento.
Object Pascal_Samplr := TCLSamplr.Create( _Contex );
O objeto " Programa " ( TCLProgra ) lê o código -fonte e o compila em um binário executável. A classe TCLProgra é criada com a classe TCLContex como um argumento. A classe TCLProgra é abstrata e serve como classe base para as classes TCLLibrar e TCLExecut , dependendo do tipo de código -fonte.
A classe TCLLibrar é um programa que não inclui funções a serem executadas diretamente é chamado de tipo de biblioteca.
Object Pascal_Librar := TCLLibrar.Create( _Contex ); _Librar.Source.LoadFromFile( ' Librar.cl ' ); // load Sourcecode
A classe TCLExecut é um programa que inclui funções ( kernel s) para executar diretamente.
Object Pascal_Execut := TCLExecut.Create( _Contex ); _Execut.Source.LoadFromFile( ' Execut.cl ' ); // load Sourcecode
Um " Build " ( TCLBuildr ) é uma "ação" realizada por um programa , mas é explicitamente representada como uma classe em nossa biblioteca.
Object Pascal_Buildr := TCLBuildr.Create( _Execut, _Device ); { or } _Buildr := _Execut.Buildrs[ _Device ]; { or } _Buildr := _Execut.BuildTo( _Device );
O objeto do kernel (consulte o Capítulo 2.8.) Cria automaticamente a classe TCLBuildr em tempo de execução. No entanto, você pode verificar erros de compilação e vinculação criando um objeto TCLBuildr antes de executar o kernel.
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
O objeto " kernel " ( TCLKernel ) representa uma função executável em um programa.
OpenCL Ckernel void Main ( ･･･ ) { ･･･ }
A classe TCLKernel é instanciada dos objetos TCLExecut e TCLQueuer .
Object Pascal_Kernel := TCLKernel.Create( _Execut, ' Main ' , _Queuer ); { or } _Kernel := _Execut.Kernels.Add( ' Main ' , _Queuer );
O objeto de memória está vinculado ao parâmetro no código -fonte através da propriedade "Parames" da 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
O programa OpenCL funciona repetidamente como uma estatura de loop triplo.
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
Você também pode especificar os índices de loop mínimo e 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
