Unduh OpenCL - Unduh Kode Sumber OpenCL

OpenCL

Kode sumber Delphi

1.0.0

Unduh

［日本語］

OpenCl

Komputasi paralel dengan opencl pada GPU dan CPU.

■ 1. `LUX.GPU.OpenCL` Library

TOpenCL ： Singleton of Tclsystem
┃
TCLSystem ： Sistem
┗ TCLPlatfos ： Daftar platform
┗ TCLPlatfo ： Platform
┣ TCLExtenss ： Daftar Ekstensi
┣ TCLDevices ： Daftar Perangkat
┃ ┗ TCLDevice ： perangkat
┗ TCLContexs ： Daftar Konteks
┗ TCLContex ： Konteks
┣ TCLQueuers ： Daftar Antrian Perintah
┃ ┗ TCLQueuer ： Antrian perintah
┣ TCLArgumes ： Daftar Argumen
┃ ┣ TCLBuffer ： buffer
┃ ┣ TCLImager ： Gambar
┃ ┗ TCLSamplr ： Sampler
┣ TCLLibrars ： Daftar Perpustakaan
┃ ┗ TCLLibrar ： Perpustakaan
┗ TCLExecuts ： Daftar program yang dapat dieksekusi
┗ TCLExecut ： Program yang dapat dieksekusi
┣ TCLBuildrs ： Daftar Bangun
┃ ┗ TCLBuildr ： Bangun
┗ TCLKernels ： Daftar Kernel
┗ TCLKernel ： Kernel
┗ TCLParames ： Daftar Parameter
┗ TCLParame ： Parameter

■ 2. Penggunaan

Kelas TOpenCL adalah singleton dari kelas TCLSystem . Kelas TCLSystem secara otomatis mendeteksi semua perangkat komputasi yang ada di mesin host.

⬤ 2.1. Platform

Objek " Platform " ( TCLPlatfo ) mewakili lingkungan yang disediakan oleh masing -masing vendor perangkat. Kelas TCLSystem secara otomatis mendeteksi semua platform S dan mencantumkannya di properti Platfos[] .

Object Pascal

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

Kelas TCLPlatfo memberikan informasi tentang platform tertentu sebagai properti.

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. Perangkat

Objek " perangkat " ( TCLDevice ) mewakili GPU fisik atau CPU. Kelas TCLPlatfo secara otomatis mendeteksi semua objek perangkat dalam objek platform tertentu dan menyebutkannya di properti Devices[] .

Object Pascal

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

Kelas TCLDevice memberikan informasi terperinci tentang setiap perangkat tertentu melalui propertinya.

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. Konteks

Objek " Konteks " ( TCLContex ) mengelola kumpulan data dan program terkait. Kelas TCLContex dipakai dari kelas TCLPlatfo .

Object Pascal

_Contex := TCLContex.Create( _Platfo );

Kelas TCLContex yang dihasilkan terdaftar di properti Contexs[] dari kelas TCLPlatfo .

Object Pascal

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

⬤ 2.4. Perintah antrian

Objek " Command Antrian " ( TCLQueuer ) mengelola perintah yang dikirim ke perangkat. Dengan kata lain, itu berfungsi sebagai jembatan antara konteks dan perangkat . Kelas TCLQueuer dibuat dengan kelas TCLContex dan TCLDevice sebagai argumen.

Object Pascal

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

Kelas TCLContex mendaftarkan objek TCLQueuer di properti Queuers[] .

Object Pascal

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

Perhatikan bahwa konteks dan perangkat pada platform yang berbeda tidak dapat menghasilkan antrian perintah .

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. Argumen

TCLArgume
┣ TCLMemory
┃ ┣ TCLBuffer
┃ ┗ TCLImager
┗ TCLSamplr

▼ 2.5.1. Ingatan

Objek " Memori " ( TCLMemory ) menyimpan berbagai data dan membagikannya dengan perangkat . Kelas TCLMemory dibuat dari kelas TCLContex dan TCLQueuer . Kelas TCLMemory abstrak dan memperoleh kelas TCLBuffer dan TCLImager .

▽ 2.5.1.1. Penyangga

Kelas TCLBuffer menyimpan array dari "tipe sederhana" atau "jenis rekaman" apa pun.

Jika Anda ingin mengirim array jenis struktur berikut ke perangkat,

OpenCL C

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

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

Hasilkan kelas TCLBuffer sebagai berikut.

Object Pascal

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

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

Baca dan tulis data array melalui properti Data . Data array harus " peta ped" untuk disinkronkan dengan host sebelum membaca atau menulis, dan " unmap ped" untuk disinkronkan dengan perangkat setelah digunakan.

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. Gambar

Objek " Image " ( TCLImager ) menyimpan array piksel dalam 1D ke 3D. Data voxel 3D juga dianggap sebagai jenis gambar 3D. Kelas TCLImager abstrak dan memperoleh berbagai kelas tergantung pada tata letak dan bit saluran warna.

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

Bagian pertama dari nama kelas mewakili dimensi gambar.

Tclimager 1D x * x *
Dimensi ： 1D
Tclimager 2D x * x *
Dimensi ： 2D
TCLIMAGER 3D X * X *
Dimensi ： 3D

Bagian kedua dari nama kelas mewakili urutan saluran warna gambar.

TCLIMAGER * X BGRA X *
Pesanan Saluran Warna ： ＢＧＲＡ
TClimager * x RGBA x *
Pesanan Saluran Warna ： ＲＧＢＡ

Bagian ketiga dari nama kelas mewakili tipe data warna suatu gambar.

TClimager * x * x UInt8
Jenis data sisi perangkat ： uint8 @ opencl c
Tipe Data sisi host ： UInt8 (Byte) @ delphi
TClimager * x * x UFix8
Jenis data sisi perangkat ： float @ opencl c
Tipe Data sisi host ： UInt8 (Byte) @ delphi
TClimager * x * x UInt32
Jenis data sisi perangkat ： uint @ opencl c
Jenis Data sisi host ： UInt32 (Cardinal) @ Delphi
TCLIMAGER * X * X SFlo32
Jenis data sisi perangkat ： float @ opencl c
Tipe Data sisi host ： Single @ delphi

Properti 'countx'/'y'/'z' menetapkan jumlah piksel dalam arah 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

▼ 2.5.2. Sampler

Objek Sampler ( TCLSamplr ) mendefinisikan metode interpolasi untuk mendapatkan warna piksel dalam koordinat nomor nyata.
Kelas TCLSamplr dihasilkan dengan kelas 'TclContex' sebagai argumen.

Object Pascal

_Samplr := TCLSamplr.Create( _Contex );

⬤ 2.6. Program

Objek " Program " ( TCLProgra ) membaca kode sumber dan mengkompilasinya menjadi biner yang dapat dieksekusi. Kelas TCLProgra dibuat dengan kelas TCLContex sebagai argumen. Kelas TCLProgra abstrak dan berfungsi sebagai kelas dasar untuk kelas TCLLibrar dan TCLExecut , tergantung pada jenis kode sumber.

▼ 2.6.1. Perpustakaan

Kelas TCLLibrar adalah program yang tidak termasuk fungsi untuk dieksekusi secara langsung disebut tipe perpustakaan.

Object Pascal

_Librar := TCLLibrar.Create( _Contex );

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

▼ 2.6.2. Dapat dieksekusi

Kelas TCLExecut adalah program yang mencakup fungsi ( kernel S) untuk dieksekusi secara langsung.

Object Pascal

_Execut := TCLExecut.Create( _Contex );

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

⬤ 2.7. Membangun

A " build " ( TCLBuildr ) adalah "tindakan" yang dilakukan oleh program , tetapi secara eksplisit direpresentasikan sebagai kelas di perpustakaan kami.

Object Pascal

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

Objek kernel (lihat Bab 2.8.) Secara otomatis membuat kelas TCLBuildr saat runtime. Namun, Anda dapat memeriksa kompilasi dan menghubungkan kesalahan dengan membuat objek TCLBuildr sebelum menjalankan 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

⬤ 2.8. Inti

Objek " kernel " ( TCLKernel ) mewakili fungsi yang dapat dieksekusi dalam suatu program.

OpenCL C

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

Kelas TCLKernel dipakai dari objek TCLExecut dan TCLQueuer .

Object Pascal

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

▼ 2.8.1. Parameter

Objek memori ditautkan ke parameter dalam kode sumber melalui properti "parames" dari kelas TCLKernel .

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. Jumlah loop

Program OpenCL berulang kali berjalan seperti pernyataan triple loop.

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

Anda juga dapat menentukan indeks loop minimum dan maksimum.

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. Berlari

Object Pascal

_Kernel.Run;  // Run

■ 3. Referensi

⬤ 3.1. The Khronos Group Inc

Khronos Opencl Registry - The Khronos Group Inc
- 3.0
  - Spesifikasi Opencl
  - Spesifikasi opencl .pdf
  - Spesifikasi OpenCl C
  - Spesifikasi OpenCl C.pdf