opencl-bindings 1.0.0pre → 1.0.0pre2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/ChangeLog +8 -0
- data/README.md +1 -1
- data/sample/hello.rb +1 -1
- data/sample/hello_clu.rb +13 -14
- data/sample/report_env.rb +431 -0
- data/sample/util/clu.rb +110 -9
- metadata +3 -2
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA1:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: aea7dd9c7cc8149f8f2fc81b86edb83da2d71343
|
|
4
|
+
data.tar.gz: 1a14cd6169148349dd56c1fba9f9322fea6b924a
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: fb1debe697a01f8c984c79abaf8f7d6a03d28d35b08ba857f1443aecff055ac2ec2628c8495f764ee84086d9c4e6aba2078ab10a925048045cd6eceb90cd7a0c
|
|
7
|
+
data.tar.gz: b350bd39fa361a6e54438e7a60365786a9b4c8deac95cc5b63dfa62ab862d3ec85b680fab290175c78b7f97c60b7496df5e5118ebf05d49180cc21ddb7a5fc80
|
data/ChangeLog
CHANGED
|
@@ -1,3 +1,11 @@
|
|
|
1
|
+
2015-11-23 vaiorabbit <http://twitter.com/vaiorabbit>
|
|
2
|
+
|
|
3
|
+
* sample/report_env.rb: Added.
|
|
4
|
+
|
|
5
|
+
2015-11-22 vaiorabbit <http://twitter.com/vaiorabbit>
|
|
6
|
+
|
|
7
|
+
* sample/Mandelbrot: Added.
|
|
8
|
+
|
|
1
9
|
2015-11-21 vaiorabbit <http://twitter.com/vaiorabbit>
|
|
2
10
|
|
|
3
11
|
* sample/QJulia/qjulia_clu.rb: Added.
|
data/README.md
CHANGED
data/sample/hello.rb
CHANGED
|
@@ -33,7 +33,7 @@ cl_device_ids = cl_devices_buf.unpack("Q#{cl_devices_entry_count}")
|
|
|
33
33
|
|
|
34
34
|
# Context
|
|
35
35
|
errcode_ret_buf = ' ' * 4
|
|
36
|
-
cl_ctx =
|
|
36
|
+
cl_ctx = clCreateContext(nil, 1, cl_devices_buf, nil, nil, errcode_ret_buf)
|
|
37
37
|
|
|
38
38
|
# Command Queues
|
|
39
39
|
cl_cq = clCreateCommandQueue(cl_ctx, cl_device_ids[0], 0, errcode_ret_buf)
|
data/sample/hello_clu.rb
CHANGED
|
@@ -23,37 +23,36 @@ clu_platform = CLUPlatform.new
|
|
|
23
23
|
clu_device = CLUDevice.new(clu_platform.platforms[0], CL_DEVICE_TYPE_DEFAULT)
|
|
24
24
|
|
|
25
25
|
# Context
|
|
26
|
-
clu_ctx = CLUContext.newContext(nil, clu_device
|
|
26
|
+
clu_ctx = CLUContext.newContext(nil, [clu_device[0]])
|
|
27
27
|
|
|
28
28
|
# Command Queues
|
|
29
|
-
clu_cq = CLUCommandQueue.newCommandQueue(clu_ctx
|
|
29
|
+
clu_cq = CLUCommandQueue.newCommandQueue(clu_ctx, clu_device[0])
|
|
30
30
|
|
|
31
31
|
# Memory Buffer
|
|
32
32
|
MEM_SIZE = 128
|
|
33
33
|
clu_memobj = CLUMemory.newBuffer(clu_ctx.context, CL_MEM_READ_WRITE, MEM_SIZE * Fiddle:: SIZEOF_CHAR)
|
|
34
34
|
|
|
35
35
|
# Program
|
|
36
|
-
|
|
37
|
-
clu_prog
|
|
38
|
-
clu_prog.buildProgram(clu_device.devices)
|
|
36
|
+
clu_prog = CLUProgram.newProgramWithSource(clu_ctx, [File.read("hello.cl")])
|
|
37
|
+
clu_prog.buildProgram([clu_device[0]])
|
|
39
38
|
|
|
40
39
|
# Kernel
|
|
41
|
-
clu_kern = CLUKernel.newKernel(clu_prog
|
|
40
|
+
clu_kern = CLUKernel.newKernel(clu_prog, "hello")
|
|
42
41
|
|
|
43
42
|
# Execute
|
|
44
|
-
clu_kern.setKernelArg(0, Fiddle::TYPE_VOIDP, [clu_memobj.
|
|
45
|
-
clu_cq.enqueueTask(clu_kern
|
|
43
|
+
clu_kern.setKernelArg(0, Fiddle::TYPE_VOIDP, [clu_memobj.handle.to_i])
|
|
44
|
+
clu_cq.enqueueTask(clu_kern)
|
|
46
45
|
|
|
47
46
|
# Result
|
|
48
47
|
result_buf = ' ' * MEM_SIZE
|
|
49
|
-
clu_cq.enqueueReadBuffer(clu_memobj
|
|
48
|
+
clu_cq.enqueueReadBuffer(clu_memobj, CL_TRUE, 0, MEM_SIZE * Fiddle::SIZEOF_CHAR, result_buf)
|
|
50
49
|
puts result_buf # => Hello, World!
|
|
51
50
|
|
|
52
51
|
# End
|
|
53
52
|
clu_cq.flush
|
|
54
53
|
clu_cq.finish
|
|
55
|
-
clu_kern.
|
|
56
|
-
clu_prog.
|
|
57
|
-
clu_memobj.
|
|
58
|
-
clu_cq.
|
|
59
|
-
clu_ctx.
|
|
54
|
+
clu_kern.release
|
|
55
|
+
clu_prog.release
|
|
56
|
+
clu_memobj.release
|
|
57
|
+
clu_cq.release
|
|
58
|
+
clu_ctx.release
|
|
@@ -0,0 +1,431 @@
|
|
|
1
|
+
require_relative '../lib/opencl'
|
|
2
|
+
require_relative '../lib/opencl_ext'
|
|
3
|
+
|
|
4
|
+
# Load DLL
|
|
5
|
+
begin
|
|
6
|
+
OpenCL.load_lib('c:/Windows/System32/OpenCL.dll') # For Windows
|
|
7
|
+
rescue
|
|
8
|
+
OpenCL.load_lib('/System/Library/Frameworks/OpenCL.framework/OpenCL') # For Mac OS X
|
|
9
|
+
end
|
|
10
|
+
include OpenCL
|
|
11
|
+
|
|
12
|
+
################################################################################
|
|
13
|
+
|
|
14
|
+
$enum2name = {
|
|
15
|
+
OpenCL::CL_DEVICE_TYPE => "CL_DEVICE_TYPE",
|
|
16
|
+
OpenCL::CL_DEVICE_VENDOR_ID => "CL_DEVICE_VENDOR_ID",
|
|
17
|
+
OpenCL::CL_DEVICE_MAX_COMPUTE_UNITS => "CL_DEVICE_MAX_COMPUTE_UNITS",
|
|
18
|
+
OpenCL::CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS => "CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS",
|
|
19
|
+
OpenCL::CL_DEVICE_MAX_WORK_GROUP_SIZE => "CL_DEVICE_MAX_WORK_GROUP_SIZE",
|
|
20
|
+
OpenCL::CL_DEVICE_MAX_WORK_ITEM_SIZES => "CL_DEVICE_MAX_WORK_ITEM_SIZES",
|
|
21
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR => "CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR",
|
|
22
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT => "CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT",
|
|
23
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT => "CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT",
|
|
24
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG => "CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG",
|
|
25
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT => "CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT",
|
|
26
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE => "CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE",
|
|
27
|
+
OpenCL::CL_DEVICE_MAX_CLOCK_FREQUENCY => "CL_DEVICE_MAX_CLOCK_FREQUENCY",
|
|
28
|
+
OpenCL::CL_DEVICE_ADDRESS_BITS => "CL_DEVICE_ADDRESS_BITS",
|
|
29
|
+
OpenCL::CL_DEVICE_MAX_READ_IMAGE_ARGS => "CL_DEVICE_MAX_READ_IMAGE_ARGS",
|
|
30
|
+
OpenCL::CL_DEVICE_MAX_WRITE_IMAGE_ARGS => "CL_DEVICE_MAX_WRITE_IMAGE_ARGS",
|
|
31
|
+
OpenCL::CL_DEVICE_MAX_MEM_ALLOC_SIZE => "CL_DEVICE_MAX_MEM_ALLOC_SIZE",
|
|
32
|
+
OpenCL::CL_DEVICE_IMAGE2D_MAX_WIDTH => "CL_DEVICE_IMAGE2D_MAX_WIDTH",
|
|
33
|
+
OpenCL::CL_DEVICE_IMAGE2D_MAX_HEIGHT => "CL_DEVICE_IMAGE2D_MAX_HEIGHT",
|
|
34
|
+
OpenCL::CL_DEVICE_IMAGE3D_MAX_WIDTH => "CL_DEVICE_IMAGE3D_MAX_WIDTH",
|
|
35
|
+
OpenCL::CL_DEVICE_IMAGE3D_MAX_HEIGHT => "CL_DEVICE_IMAGE3D_MAX_HEIGHT",
|
|
36
|
+
OpenCL::CL_DEVICE_IMAGE3D_MAX_DEPTH => "CL_DEVICE_IMAGE3D_MAX_DEPTH",
|
|
37
|
+
OpenCL::CL_DEVICE_IMAGE_SUPPORT => "CL_DEVICE_IMAGE_SUPPORT",
|
|
38
|
+
OpenCL::CL_DEVICE_MAX_PARAMETER_SIZE => "CL_DEVICE_MAX_PARAMETER_SIZE",
|
|
39
|
+
OpenCL::CL_DEVICE_MAX_SAMPLERS => "CL_DEVICE_MAX_SAMPLERS",
|
|
40
|
+
OpenCL::CL_DEVICE_MEM_BASE_ADDR_ALIGN => "CL_DEVICE_MEM_BASE_ADDR_ALIGN",
|
|
41
|
+
OpenCL::CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE => "CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE",
|
|
42
|
+
OpenCL::CL_DEVICE_SINGLE_FP_CONFIG => "CL_DEVICE_SINGLE_FP_CONFIG",
|
|
43
|
+
OpenCL::CL_DEVICE_GLOBAL_MEM_CACHE_TYPE => "CL_DEVICE_GLOBAL_MEM_CACHE_TYPE",
|
|
44
|
+
OpenCL::CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE => "CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE",
|
|
45
|
+
OpenCL::CL_DEVICE_GLOBAL_MEM_CACHE_SIZE => "CL_DEVICE_GLOBAL_MEM_CACHE_SIZE",
|
|
46
|
+
OpenCL::CL_DEVICE_GLOBAL_MEM_SIZE => "CL_DEVICE_GLOBAL_MEM_SIZE",
|
|
47
|
+
OpenCL::CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE => "CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE",
|
|
48
|
+
OpenCL::CL_DEVICE_MAX_CONSTANT_ARGS => "CL_DEVICE_MAX_CONSTANT_ARGS",
|
|
49
|
+
OpenCL::CL_DEVICE_LOCAL_MEM_TYPE => "CL_DEVICE_LOCAL_MEM_TYPE",
|
|
50
|
+
OpenCL::CL_DEVICE_LOCAL_MEM_SIZE => "CL_DEVICE_LOCAL_MEM_SIZE",
|
|
51
|
+
OpenCL::CL_DEVICE_ERROR_CORRECTION_SUPPORT => "CL_DEVICE_ERROR_CORRECTION_SUPPORT",
|
|
52
|
+
OpenCL::CL_DEVICE_PROFILING_TIMER_RESOLUTION => "CL_DEVICE_PROFILING_TIMER_RESOLUTION",
|
|
53
|
+
OpenCL::CL_DEVICE_ENDIAN_LITTLE => "CL_DEVICE_ENDIAN_LITTLE",
|
|
54
|
+
OpenCL::CL_DEVICE_AVAILABLE => "CL_DEVICE_AVAILABLE",
|
|
55
|
+
OpenCL::CL_DEVICE_COMPILER_AVAILABLE => "CL_DEVICE_COMPILER_AVAILABLE",
|
|
56
|
+
OpenCL::CL_DEVICE_EXECUTION_CAPABILITIES => "CL_DEVICE_EXECUTION_CAPABILITIES",
|
|
57
|
+
OpenCL::CL_DEVICE_QUEUE_PROPERTIES => "CL_DEVICE_QUEUE_PROPERTIES",
|
|
58
|
+
OpenCL::CL_DEVICE_NAME => "CL_DEVICE_NAME",
|
|
59
|
+
OpenCL::CL_DEVICE_VENDOR => "CL_DEVICE_VENDOR",
|
|
60
|
+
OpenCL::CL_DRIVER_VERSION => "CL_DRIVER_VERSION",
|
|
61
|
+
OpenCL::CL_DEVICE_PROFILE => "CL_DEVICE_PROFILE",
|
|
62
|
+
OpenCL::CL_DEVICE_VERSION => "CL_DEVICE_VERSION",
|
|
63
|
+
OpenCL::CL_DEVICE_EXTENSIONS => "CL_DEVICE_EXTENSIONS",
|
|
64
|
+
OpenCL::CL_DEVICE_PLATFORM => "CL_DEVICE_PLATFORM",
|
|
65
|
+
OpenCL::CL_DEVICE_DOUBLE_FP_CONFIG => "CL_DEVICE_DOUBLE_FP_CONFIG",
|
|
66
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF => "CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF",
|
|
67
|
+
OpenCL::CL_DEVICE_HOST_UNIFIED_MEMORY => "CL_DEVICE_HOST_UNIFIED_MEMORY",
|
|
68
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR => "CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR",
|
|
69
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT => "CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT",
|
|
70
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_INT => "CL_DEVICE_NATIVE_VECTOR_WIDTH_INT",
|
|
71
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG => "CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG",
|
|
72
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT => "CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT",
|
|
73
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE => "CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE",
|
|
74
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF => "CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF",
|
|
75
|
+
OpenCL::CL_DEVICE_OPENCL_C_VERSION => "CL_DEVICE_OPENCL_C_VERSION",
|
|
76
|
+
OpenCL::CL_DEVICE_LINKER_AVAILABLE => "CL_DEVICE_LINKER_AVAILABLE",
|
|
77
|
+
OpenCL::CL_DEVICE_BUILT_IN_KERNELS => "CL_DEVICE_BUILT_IN_KERNELS",
|
|
78
|
+
OpenCL::CL_DEVICE_IMAGE_MAX_BUFFER_SIZE => "CL_DEVICE_IMAGE_MAX_BUFFER_SIZE",
|
|
79
|
+
OpenCL::CL_DEVICE_IMAGE_MAX_ARRAY_SIZE => "CL_DEVICE_IMAGE_MAX_ARRAY_SIZE",
|
|
80
|
+
OpenCL::CL_DEVICE_PARENT_DEVICE => "CL_DEVICE_PARENT_DEVICE",
|
|
81
|
+
OpenCL::CL_DEVICE_PARTITION_MAX_SUB_DEVICES => "CL_DEVICE_PARTITION_MAX_SUB_DEVICES",
|
|
82
|
+
OpenCL::CL_DEVICE_PARTITION_PROPERTIES => "CL_DEVICE_PARTITION_PROPERTIES",
|
|
83
|
+
OpenCL::CL_DEVICE_PARTITION_AFFINITY_DOMAIN => "CL_DEVICE_PARTITION_AFFINITY_DOMAIN",
|
|
84
|
+
OpenCL::CL_DEVICE_PARTITION_TYPE => "CL_DEVICE_PARTITION_TYPE",
|
|
85
|
+
OpenCL::CL_DEVICE_REFERENCE_COUNT => "CL_DEVICE_REFERENCE_COUNT",
|
|
86
|
+
OpenCL::CL_DEVICE_PREFERRED_INTEROP_USER_SYNC => "CL_DEVICE_PREFERRED_INTEROP_USER_SYNC",
|
|
87
|
+
OpenCL::CL_DEVICE_PRINTF_BUFFER_SIZE => "CL_DEVICE_PRINTF_BUFFER_SIZE",
|
|
88
|
+
OpenCL::CL_DEVICE_IMAGE_PITCH_ALIGNMENT => "CL_DEVICE_IMAGE_PITCH_ALIGNMENT",
|
|
89
|
+
OpenCL::CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT => "CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT"
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
$enum2pack = {
|
|
93
|
+
OpenCL::CL_DEVICE_TYPE => "L",
|
|
94
|
+
OpenCL::CL_DEVICE_VENDOR_ID => "L",
|
|
95
|
+
OpenCL::CL_DEVICE_MAX_COMPUTE_UNITS => "L",
|
|
96
|
+
OpenCL::CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS => "L",
|
|
97
|
+
OpenCL::CL_DEVICE_MAX_WORK_GROUP_SIZE => "L",
|
|
98
|
+
OpenCL::CL_DEVICE_MAX_WORK_ITEM_SIZES => "L3",
|
|
99
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR => "L",
|
|
100
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT => "L",
|
|
101
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT => "L",
|
|
102
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG => "L",
|
|
103
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT => "L",
|
|
104
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE => "L",
|
|
105
|
+
OpenCL::CL_DEVICE_MAX_CLOCK_FREQUENCY => "L",
|
|
106
|
+
OpenCL::CL_DEVICE_ADDRESS_BITS => "L",
|
|
107
|
+
OpenCL::CL_DEVICE_MAX_READ_IMAGE_ARGS => "L",
|
|
108
|
+
OpenCL::CL_DEVICE_MAX_WRITE_IMAGE_ARGS => "L",
|
|
109
|
+
OpenCL::CL_DEVICE_MAX_MEM_ALLOC_SIZE => "L",
|
|
110
|
+
OpenCL::CL_DEVICE_IMAGE2D_MAX_WIDTH => "L",
|
|
111
|
+
OpenCL::CL_DEVICE_IMAGE2D_MAX_HEIGHT => "L",
|
|
112
|
+
OpenCL::CL_DEVICE_IMAGE3D_MAX_WIDTH => "L",
|
|
113
|
+
OpenCL::CL_DEVICE_IMAGE3D_MAX_HEIGHT => "L",
|
|
114
|
+
OpenCL::CL_DEVICE_IMAGE3D_MAX_DEPTH => "L",
|
|
115
|
+
OpenCL::CL_DEVICE_IMAGE_SUPPORT => "cl_bool",
|
|
116
|
+
OpenCL::CL_DEVICE_MAX_PARAMETER_SIZE => "L",
|
|
117
|
+
OpenCL::CL_DEVICE_MAX_SAMPLERS => "L",
|
|
118
|
+
OpenCL::CL_DEVICE_MEM_BASE_ADDR_ALIGN => "L",
|
|
119
|
+
OpenCL::CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE => "L",
|
|
120
|
+
OpenCL::CL_DEVICE_SINGLE_FP_CONFIG => "cl_bitfield",
|
|
121
|
+
OpenCL::CL_DEVICE_GLOBAL_MEM_CACHE_TYPE => "L",
|
|
122
|
+
OpenCL::CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE => "L",
|
|
123
|
+
OpenCL::CL_DEVICE_GLOBAL_MEM_CACHE_SIZE => "L",
|
|
124
|
+
OpenCL::CL_DEVICE_GLOBAL_MEM_SIZE => "L",
|
|
125
|
+
OpenCL::CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE => "L",
|
|
126
|
+
OpenCL::CL_DEVICE_MAX_CONSTANT_ARGS => "L",
|
|
127
|
+
OpenCL::CL_DEVICE_LOCAL_MEM_TYPE => "L",
|
|
128
|
+
OpenCL::CL_DEVICE_LOCAL_MEM_SIZE => "L",
|
|
129
|
+
OpenCL::CL_DEVICE_ERROR_CORRECTION_SUPPORT => "cl_bool",
|
|
130
|
+
OpenCL::CL_DEVICE_PROFILING_TIMER_RESOLUTION => "L",
|
|
131
|
+
OpenCL::CL_DEVICE_ENDIAN_LITTLE => "cl_bool",
|
|
132
|
+
OpenCL::CL_DEVICE_AVAILABLE => "cl_bool",
|
|
133
|
+
OpenCL::CL_DEVICE_COMPILER_AVAILABLE => "cl_bool",
|
|
134
|
+
OpenCL::CL_DEVICE_EXECUTION_CAPABILITIES => "L",
|
|
135
|
+
OpenCL::CL_DEVICE_QUEUE_PROPERTIES => "cl_bitfield",
|
|
136
|
+
OpenCL::CL_DEVICE_NAME => "Z*",
|
|
137
|
+
OpenCL::CL_DEVICE_VENDOR => "Z*",
|
|
138
|
+
OpenCL::CL_DRIVER_VERSION => "Z*",
|
|
139
|
+
OpenCL::CL_DEVICE_PROFILE => "Z*",
|
|
140
|
+
OpenCL::CL_DEVICE_VERSION => "Z*",
|
|
141
|
+
OpenCL::CL_DEVICE_EXTENSIONS => "Z*",
|
|
142
|
+
OpenCL::CL_DEVICE_PLATFORM => "Q",
|
|
143
|
+
OpenCL::CL_DEVICE_DOUBLE_FP_CONFIG => "cl_bitfield",
|
|
144
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF => "L",
|
|
145
|
+
OpenCL::CL_DEVICE_HOST_UNIFIED_MEMORY => "cl_bool",
|
|
146
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR => "L",
|
|
147
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT => "L",
|
|
148
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_INT => "L",
|
|
149
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG => "L",
|
|
150
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT => "L",
|
|
151
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE => "L",
|
|
152
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF => "L",
|
|
153
|
+
OpenCL::CL_DEVICE_OPENCL_C_VERSION => "Z*",
|
|
154
|
+
OpenCL::CL_DEVICE_LINKER_AVAILABLE => "cl_bool",
|
|
155
|
+
OpenCL::CL_DEVICE_BUILT_IN_KERNELS => "Z*",
|
|
156
|
+
OpenCL::CL_DEVICE_IMAGE_MAX_BUFFER_SIZE => "L",
|
|
157
|
+
OpenCL::CL_DEVICE_IMAGE_MAX_ARRAY_SIZE => "L",
|
|
158
|
+
OpenCL::CL_DEVICE_PARENT_DEVICE => "Q",
|
|
159
|
+
OpenCL::CL_DEVICE_PARTITION_MAX_SUB_DEVICES => "L",
|
|
160
|
+
OpenCL::CL_DEVICE_PARTITION_PROPERTIES => "L",
|
|
161
|
+
OpenCL::CL_DEVICE_PARTITION_AFFINITY_DOMAIN => "cl_bitfield",
|
|
162
|
+
OpenCL::CL_DEVICE_PARTITION_TYPE => "L",
|
|
163
|
+
OpenCL::CL_DEVICE_REFERENCE_COUNT => "L",
|
|
164
|
+
OpenCL::CL_DEVICE_PREFERRED_INTEROP_USER_SYNC => "L",
|
|
165
|
+
OpenCL::CL_DEVICE_PRINTF_BUFFER_SIZE => "L",
|
|
166
|
+
OpenCL::CL_DEVICE_IMAGE_PITCH_ALIGNMENT => "L",
|
|
167
|
+
OpenCL::CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT => "L"
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
def print_device_info(device_id)
|
|
171
|
+
err = 0
|
|
172
|
+
errcode_ret_buf = ' ' * 4
|
|
173
|
+
info_buf = ' ' * 1024
|
|
174
|
+
|
|
175
|
+
enums = [
|
|
176
|
+
OpenCL::CL_DEVICE_TYPE,
|
|
177
|
+
OpenCL::CL_DEVICE_VENDOR_ID,
|
|
178
|
+
OpenCL::CL_DEVICE_MAX_COMPUTE_UNITS,
|
|
179
|
+
OpenCL::CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS,
|
|
180
|
+
OpenCL::CL_DEVICE_MAX_WORK_GROUP_SIZE,
|
|
181
|
+
OpenCL::CL_DEVICE_MAX_WORK_ITEM_SIZES,
|
|
182
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR,
|
|
183
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT,
|
|
184
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT,
|
|
185
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG,
|
|
186
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT,
|
|
187
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE,
|
|
188
|
+
OpenCL::CL_DEVICE_MAX_CLOCK_FREQUENCY,
|
|
189
|
+
OpenCL::CL_DEVICE_ADDRESS_BITS,
|
|
190
|
+
OpenCL::CL_DEVICE_MAX_READ_IMAGE_ARGS,
|
|
191
|
+
OpenCL::CL_DEVICE_MAX_WRITE_IMAGE_ARGS,
|
|
192
|
+
OpenCL::CL_DEVICE_MAX_MEM_ALLOC_SIZE,
|
|
193
|
+
OpenCL::CL_DEVICE_IMAGE2D_MAX_WIDTH,
|
|
194
|
+
OpenCL::CL_DEVICE_IMAGE2D_MAX_HEIGHT,
|
|
195
|
+
OpenCL::CL_DEVICE_IMAGE3D_MAX_WIDTH,
|
|
196
|
+
OpenCL::CL_DEVICE_IMAGE3D_MAX_HEIGHT,
|
|
197
|
+
OpenCL::CL_DEVICE_IMAGE3D_MAX_DEPTH,
|
|
198
|
+
OpenCL::CL_DEVICE_IMAGE_SUPPORT,
|
|
199
|
+
OpenCL::CL_DEVICE_MAX_PARAMETER_SIZE,
|
|
200
|
+
OpenCL::CL_DEVICE_MAX_SAMPLERS,
|
|
201
|
+
OpenCL::CL_DEVICE_MEM_BASE_ADDR_ALIGN,
|
|
202
|
+
OpenCL::CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE,
|
|
203
|
+
OpenCL::CL_DEVICE_SINGLE_FP_CONFIG,
|
|
204
|
+
OpenCL::CL_DEVICE_GLOBAL_MEM_CACHE_TYPE,
|
|
205
|
+
OpenCL::CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE,
|
|
206
|
+
OpenCL::CL_DEVICE_GLOBAL_MEM_CACHE_SIZE,
|
|
207
|
+
OpenCL::CL_DEVICE_GLOBAL_MEM_SIZE,
|
|
208
|
+
OpenCL::CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE,
|
|
209
|
+
OpenCL::CL_DEVICE_MAX_CONSTANT_ARGS,
|
|
210
|
+
OpenCL::CL_DEVICE_LOCAL_MEM_TYPE,
|
|
211
|
+
OpenCL::CL_DEVICE_LOCAL_MEM_SIZE,
|
|
212
|
+
OpenCL::CL_DEVICE_ERROR_CORRECTION_SUPPORT,
|
|
213
|
+
OpenCL::CL_DEVICE_PROFILING_TIMER_RESOLUTION,
|
|
214
|
+
OpenCL::CL_DEVICE_ENDIAN_LITTLE,
|
|
215
|
+
OpenCL::CL_DEVICE_AVAILABLE,
|
|
216
|
+
OpenCL::CL_DEVICE_COMPILER_AVAILABLE,
|
|
217
|
+
OpenCL::CL_DEVICE_EXECUTION_CAPABILITIES,
|
|
218
|
+
OpenCL::CL_DEVICE_QUEUE_PROPERTIES,
|
|
219
|
+
OpenCL::CL_DEVICE_NAME,
|
|
220
|
+
OpenCL::CL_DEVICE_VENDOR,
|
|
221
|
+
OpenCL::CL_DRIVER_VERSION,
|
|
222
|
+
OpenCL::CL_DEVICE_PROFILE,
|
|
223
|
+
OpenCL::CL_DEVICE_VERSION,
|
|
224
|
+
OpenCL::CL_DEVICE_EXTENSIONS,
|
|
225
|
+
OpenCL::CL_DEVICE_PLATFORM,
|
|
226
|
+
OpenCL::CL_DEVICE_DOUBLE_FP_CONFIG,
|
|
227
|
+
OpenCL::CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF,
|
|
228
|
+
OpenCL::CL_DEVICE_HOST_UNIFIED_MEMORY,
|
|
229
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR,
|
|
230
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT,
|
|
231
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_INT,
|
|
232
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG,
|
|
233
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT,
|
|
234
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE,
|
|
235
|
+
OpenCL::CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF,
|
|
236
|
+
OpenCL::CL_DEVICE_OPENCL_C_VERSION,
|
|
237
|
+
OpenCL::CL_DEVICE_LINKER_AVAILABLE,
|
|
238
|
+
OpenCL::CL_DEVICE_BUILT_IN_KERNELS,
|
|
239
|
+
OpenCL::CL_DEVICE_IMAGE_MAX_BUFFER_SIZE,
|
|
240
|
+
OpenCL::CL_DEVICE_IMAGE_MAX_ARRAY_SIZE,
|
|
241
|
+
OpenCL::CL_DEVICE_PARENT_DEVICE,
|
|
242
|
+
OpenCL::CL_DEVICE_PARTITION_MAX_SUB_DEVICES,
|
|
243
|
+
OpenCL::CL_DEVICE_PARTITION_PROPERTIES,
|
|
244
|
+
OpenCL::CL_DEVICE_PARTITION_AFFINITY_DOMAIN,
|
|
245
|
+
OpenCL::CL_DEVICE_PARTITION_TYPE,
|
|
246
|
+
OpenCL::CL_DEVICE_REFERENCE_COUNT,
|
|
247
|
+
OpenCL::CL_DEVICE_PREFERRED_INTEROP_USER_SYNC,
|
|
248
|
+
OpenCL::CL_DEVICE_PRINTF_BUFFER_SIZE,
|
|
249
|
+
OpenCL::CL_DEVICE_IMAGE_PITCH_ALIGNMENT,
|
|
250
|
+
OpenCL::CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT,
|
|
251
|
+
]
|
|
252
|
+
|
|
253
|
+
enums.each do |e|
|
|
254
|
+
err = clGetDeviceInfo(device_id, e, info_buf.length, info_buf, nil)
|
|
255
|
+
|
|
256
|
+
if $enum2pack[e] == "cl_bool"
|
|
257
|
+
info = info_buf.unpack($enum2pack[e])
|
|
258
|
+
info = "#{info == 0 ? 'false' : 'true'}"
|
|
259
|
+
elsif $enum2pack[e] == "cl_bitfield"
|
|
260
|
+
info = info_buf.unpack("L")[0]
|
|
261
|
+
info = "#{info} (0b#{info.to_s(2)})"
|
|
262
|
+
else
|
|
263
|
+
info = info_buf.unpack($enum2pack[e])
|
|
264
|
+
end
|
|
265
|
+
|
|
266
|
+
if e == OpenCL::CL_DEVICE_EXTENSIONS
|
|
267
|
+
extensions = info[0].split
|
|
268
|
+
puts "CL_DEVICE_EXTENSIONS: "
|
|
269
|
+
extensions.each do |extension|
|
|
270
|
+
puts "\t#{extension}"
|
|
271
|
+
end
|
|
272
|
+
else
|
|
273
|
+
puts "#{$enum2name[e]}: \t#{info}"
|
|
274
|
+
end
|
|
275
|
+
end
|
|
276
|
+
end
|
|
277
|
+
|
|
278
|
+
################################################################################
|
|
279
|
+
|
|
280
|
+
$imageformat2name = {
|
|
281
|
+
# cl_channel_order
|
|
282
|
+
OpenCL::CL_R => "CL_R",
|
|
283
|
+
OpenCL::CL_A => "CL_A",
|
|
284
|
+
OpenCL::CL_RG => "CL_RG",
|
|
285
|
+
OpenCL::CL_RA => "CL_RA",
|
|
286
|
+
OpenCL::CL_RGB => "CL_RGB",
|
|
287
|
+
OpenCL::CL_RGBA => "CL_RGBA",
|
|
288
|
+
OpenCL::CL_BGRA => "CL_BGRA",
|
|
289
|
+
OpenCL::CL_ARGB => "CL_ARGB",
|
|
290
|
+
OpenCL::CL_INTENSITY => "CL_INTENSITY",
|
|
291
|
+
OpenCL::CL_LUMINANCE => "CL_LUMINANCE",
|
|
292
|
+
OpenCL::CL_Rx => "CL_Rx",
|
|
293
|
+
OpenCL::CL_RGx => "CL_RGx",
|
|
294
|
+
OpenCL::CL_RGBx => "CL_RGBx",
|
|
295
|
+
OpenCL::CL_DEPTH => "CL_DEPTH",
|
|
296
|
+
OpenCL::CL_DEPTH_STENCIL => "CL_DEPTH_STENCIL",
|
|
297
|
+
|
|
298
|
+
# cl_channel_type
|
|
299
|
+
OpenCL::CL_SNORM_INT8 => "CL_SNORM_INT8",
|
|
300
|
+
OpenCL::CL_SNORM_INT16 => "CL_SNORM_INT16",
|
|
301
|
+
OpenCL::CL_UNORM_INT8 => "CL_UNORM_INT8",
|
|
302
|
+
OpenCL::CL_UNORM_INT16 => "CL_UNORM_INT16",
|
|
303
|
+
OpenCL::CL_UNORM_SHORT_565 => "CL_UNORM_SHORT_565",
|
|
304
|
+
OpenCL::CL_UNORM_SHORT_555 => "CL_UNORM_SHORT_555",
|
|
305
|
+
OpenCL::CL_UNORM_INT_101010 => "CL_UNORM_INT_101010",
|
|
306
|
+
OpenCL::CL_SIGNED_INT8 => "CL_SIGNED_INT8",
|
|
307
|
+
OpenCL::CL_SIGNED_INT16 => "CL_SIGNED_INT16",
|
|
308
|
+
OpenCL::CL_SIGNED_INT32 => "CL_SIGNED_INT32",
|
|
309
|
+
OpenCL::CL_UNSIGNED_INT8 => "CL_UNSIGNED_INT8",
|
|
310
|
+
OpenCL::CL_UNSIGNED_INT16 => "CL_UNSIGNED_INT16",
|
|
311
|
+
OpenCL::CL_UNSIGNED_INT32 => "CL_UNSIGNED_INT32",
|
|
312
|
+
OpenCL::CL_HALF_FLOAT => "CL_HALF_FLOAT",
|
|
313
|
+
OpenCL::CL_FLOAT => "CL_FLOAT",
|
|
314
|
+
OpenCL::CL_UNORM_INT24 => "CL_UNORM_INT24",
|
|
315
|
+
|
|
316
|
+
# 0x10000012 : ABGR and xBGR formats for CoreImage CL-GPU support (from /OpenCL.framework/Headers/cl_ext.h)
|
|
317
|
+
OpenCL::CL_ABGR_APPLE => "CL_ABGR_APPLE",
|
|
318
|
+
|
|
319
|
+
# cl_APPLE_fixed_alpha_channel_orders (from /OpenCL.framework/Headers/cl_ext.h)
|
|
320
|
+
|
|
321
|
+
# 0x10000006
|
|
322
|
+
OpenCL::CL_1RGB_APPLE => "CL_1RGB_APPLE",
|
|
323
|
+
# 0x10000007
|
|
324
|
+
OpenCL::CL_BGR1_APPLE => "CL_BGR1_APPLE",
|
|
325
|
+
|
|
326
|
+
# cl_APPLE_biased_fixed_point_image_formats (from /OpenCL.framework/Headers/cl_ext.h)
|
|
327
|
+
|
|
328
|
+
# 0x10000008
|
|
329
|
+
CL_SFIXED14_APPLE => "CL_SFIXED14_APPLE",
|
|
330
|
+
# 0x10000009
|
|
331
|
+
CL_BIASED_HALF_APPLE => "CL_BIASED_HALF_APPLE",
|
|
332
|
+
|
|
333
|
+
# YUV image support (from /OpenCL.framework/Headers/cl_ext.h)
|
|
334
|
+
|
|
335
|
+
# 0x10000010
|
|
336
|
+
OpenCL::CL_YCbYCr_APPLE => "OpenCL::CL_YCbYCr_APPLE",
|
|
337
|
+
# 0x10000011
|
|
338
|
+
OpenCL::CL_CbYCrY_APPLE => "OpenCL::CL_CbYCrY_APPLE",
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
def print_supported_image_formats(cl_ctx, image_type = OpenCL::CL_MEM_OBJECT_IMAGE2D)
|
|
342
|
+
return unless (image_type == CL_MEM_OBJECT_IMAGE2D || image_type == CL_MEM_OBJECT_IMAGE3D)
|
|
343
|
+
err = 0
|
|
344
|
+
|
|
345
|
+
image_formats = []
|
|
346
|
+
|
|
347
|
+
num_image_formamts_buf = ' ' * 4
|
|
348
|
+
err = clGetSupportedImageFormats(cl_ctx, CL_MEM_READ_ONLY, image_type, 0, nil, num_image_formamts_buf)
|
|
349
|
+
num_image_formamts = num_image_formamts_buf.unpack("L")[0]
|
|
350
|
+
image_formats_buf = Fiddle::Pointer.malloc(num_image_formamts * OpenCL::CL_STRUCT_IMAGE_FORMAT.size)
|
|
351
|
+
err = clGetSupportedImageFormats(cl_ctx, CL_MEM_READ_ONLY, image_type, num_image_formamts, image_formats_buf, nil)
|
|
352
|
+
|
|
353
|
+
num_image_formamts.times do |i|
|
|
354
|
+
fmt = OpenCL::CL_STRUCT_IMAGE_FORMAT.new(image_formats_buf.to_i + i * OpenCL::CL_STRUCT_IMAGE_FORMAT.size)
|
|
355
|
+
image_formats << fmt
|
|
356
|
+
end
|
|
357
|
+
|
|
358
|
+
puts "Supported Image Formats (#{image_type == CL_MEM_OBJECT_IMAGE2D ? '2D' : '3D'})"
|
|
359
|
+
image_formats.each_with_index do |fmt, i|
|
|
360
|
+
puts "\t#{i}:\t#{$imageformat2name[fmt.image_channel_order]} - #{$imageformat2name[fmt.image_channel_data_type]}"
|
|
361
|
+
end
|
|
362
|
+
end
|
|
363
|
+
|
|
364
|
+
################################################################################
|
|
365
|
+
|
|
366
|
+
if __FILE__ == $0
|
|
367
|
+
|
|
368
|
+
err = 0
|
|
369
|
+
errcode_ret_buf = ' ' * 4
|
|
370
|
+
info_buf = ' ' * 1024
|
|
371
|
+
|
|
372
|
+
# Platform
|
|
373
|
+
cl_platforms_count_buf = ' ' * 4
|
|
374
|
+
err = clGetPlatformIDs(0, nil, cl_platforms_count_buf)
|
|
375
|
+
cl_platforms_count = cl_platforms_count_buf.unpack("L")[0]
|
|
376
|
+
|
|
377
|
+
cl_platforms_buf = ' ' * 8 * cl_platforms_count
|
|
378
|
+
err = clGetPlatformIDs(cl_platforms_count, cl_platforms_buf, nil)
|
|
379
|
+
cl_platforms = cl_platforms_buf.unpack("Q#{cl_platforms_count}")
|
|
380
|
+
|
|
381
|
+
platform_info_params = {
|
|
382
|
+
CL_PLATFORM_PROFILE => "CL_PLATFORM_PROFILE",
|
|
383
|
+
CL_PLATFORM_VERSION => "CL_PLATFORM_VERSION",
|
|
384
|
+
CL_PLATFORM_NAME => "CL_PLATFORM_NAME",
|
|
385
|
+
CL_PLATFORM_VENDOR => "CL_PLATFORM_VENDOR",
|
|
386
|
+
}
|
|
387
|
+
platform_info_params.each do |k, v|
|
|
388
|
+
err = clGetPlatformInfo(cl_platforms[0], k, info_buf.length, info_buf, nil)
|
|
389
|
+
puts "#{v}: \t#{info_buf.unpack("Z*")[0]}"
|
|
390
|
+
end
|
|
391
|
+
|
|
392
|
+
err = clGetPlatformInfo(cl_platforms[0], CL_PLATFORM_EXTENSIONS, info_buf.length, info_buf, nil)
|
|
393
|
+
extensions = info_buf.unpack("Z*")[0].split
|
|
394
|
+
puts "CL_PLATFORM_EXTENSIONS: "
|
|
395
|
+
extensions.each do |extension|
|
|
396
|
+
puts "\t#{extension}"
|
|
397
|
+
end
|
|
398
|
+
puts ""
|
|
399
|
+
|
|
400
|
+
# Devices
|
|
401
|
+
cl_devices_count_buf = ' ' * 4
|
|
402
|
+
|
|
403
|
+
err = clGetDeviceIDs(cl_platforms[0], CL_DEVICE_TYPE_ALL, 0, nil, cl_devices_count_buf)
|
|
404
|
+
cl_devices_count = cl_devices_count_buf.unpack("L")[0]
|
|
405
|
+
|
|
406
|
+
exit if cl_devices_count == 0
|
|
407
|
+
|
|
408
|
+
cl_devices_buf = ' ' * 8 * cl_devices_count
|
|
409
|
+
err = clGetDeviceIDs(cl_platforms[0], CL_DEVICE_TYPE_ALL, cl_devices_count, cl_devices_buf, nil)
|
|
410
|
+
cl_devices = cl_devices_buf.unpack("Q#{cl_devices_count}")
|
|
411
|
+
|
|
412
|
+
cl_devices_count.times do |i|
|
|
413
|
+
err = clGetDeviceInfo(cl_devices[i], CL_DEVICE_NAME, info_buf.length, info_buf, nil)
|
|
414
|
+
puts "================================================================================"
|
|
415
|
+
puts "CL_DEVICE_NAME: #{info_buf.unpack("Z*")[0]}"
|
|
416
|
+
puts "================================================================================"
|
|
417
|
+
print_device_info(cl_devices[i])
|
|
418
|
+
puts ""
|
|
419
|
+
end
|
|
420
|
+
|
|
421
|
+
# Supported Image Formats
|
|
422
|
+
cl_ctx = clCreateContext(nil, cl_devices_count, cl_devices.pack("Q*"), nil, nil, nil)
|
|
423
|
+
|
|
424
|
+
# 2D
|
|
425
|
+
print_supported_image_formats(cl_ctx, CL_MEM_OBJECT_IMAGE2D)
|
|
426
|
+
|
|
427
|
+
puts ""
|
|
428
|
+
|
|
429
|
+
# 3D
|
|
430
|
+
print_supported_image_formats(cl_ctx, CL_MEM_OBJECT_IMAGE3D)
|
|
431
|
+
end
|
data/sample/util/clu.rb
CHANGED
|
@@ -18,6 +18,10 @@ class CLUPlatform
|
|
|
18
18
|
return @platforms
|
|
19
19
|
end
|
|
20
20
|
|
|
21
|
+
def [](index)
|
|
22
|
+
platforms[index]
|
|
23
|
+
end
|
|
24
|
+
|
|
21
25
|
def getPlatformIDs(error_info: nil)
|
|
22
26
|
# cl_uint : num_entries
|
|
23
27
|
# cl_platform_id* : platforms
|
|
@@ -65,6 +69,10 @@ class CLUDevice
|
|
|
65
69
|
end
|
|
66
70
|
end
|
|
67
71
|
|
|
72
|
+
def [](index)
|
|
73
|
+
@devices[index]
|
|
74
|
+
end
|
|
75
|
+
|
|
68
76
|
# cl_platform_id : platform
|
|
69
77
|
# cl_device_type : device_type
|
|
70
78
|
def getDeviceIDs(platform, device_type, error_info: nil)
|
|
@@ -96,6 +104,8 @@ class CLUDevice
|
|
|
96
104
|
end
|
|
97
105
|
end
|
|
98
106
|
|
|
107
|
+
alias_method :retain, :retainDevices
|
|
108
|
+
|
|
99
109
|
# cl_device_id : device
|
|
100
110
|
def releaseDevice(device: @devices[0], error_info: nil)
|
|
101
111
|
return OpenCL.clReleaseDevice(device)
|
|
@@ -108,6 +118,8 @@ class CLUDevice
|
|
|
108
118
|
end
|
|
109
119
|
end
|
|
110
120
|
|
|
121
|
+
alias_method :release, :releaseDevices
|
|
122
|
+
|
|
111
123
|
# cl_device_id : device
|
|
112
124
|
# cl_device_info : param_name
|
|
113
125
|
def getDeviceInfo(param_name, device: @devices[0], error_info: nil)
|
|
@@ -247,11 +259,16 @@ class CLUContext
|
|
|
247
259
|
@context = nil # cl_context
|
|
248
260
|
end
|
|
249
261
|
|
|
262
|
+
def handle
|
|
263
|
+
@context
|
|
264
|
+
end
|
|
265
|
+
|
|
250
266
|
# cl_context_properties * : properties
|
|
251
267
|
# cl_device_id * : devices
|
|
252
268
|
# void * : pfn_notify(char *, void *, size_t, void *),
|
|
253
269
|
# void * : user_data
|
|
254
270
|
def createContext(properties, devices, pfn_notify: nil, user_data: nil, error_info: nil)
|
|
271
|
+
devices = devices.devices if devices.kind_of? CLUDevice
|
|
255
272
|
packed_properties = properties == nil ? nil : properties.pack("Q*")
|
|
256
273
|
num_devices = devices.length
|
|
257
274
|
errcode_ret_buf = ' ' * 4
|
|
@@ -328,11 +345,15 @@ class CLUContext
|
|
|
328
345
|
return OpenCL.clRetainContext(context)
|
|
329
346
|
end
|
|
330
347
|
|
|
348
|
+
alias_method :retain, :retainContext
|
|
349
|
+
|
|
331
350
|
# cl_context : context
|
|
332
351
|
def releaseContext(context: @context)
|
|
333
352
|
return OpenCL.clReleaseContext(context)
|
|
334
353
|
end
|
|
335
354
|
|
|
355
|
+
alias_method :release, :releaseContext
|
|
356
|
+
|
|
336
357
|
# cl_context : context
|
|
337
358
|
# cl_context_info : param_name
|
|
338
359
|
def getContextInfo(param_name, context: @context, error_info: nil)
|
|
@@ -394,11 +415,16 @@ class CLUMemory
|
|
|
394
415
|
@mem = nil
|
|
395
416
|
end
|
|
396
417
|
|
|
418
|
+
def handle
|
|
419
|
+
@mem
|
|
420
|
+
end
|
|
421
|
+
|
|
397
422
|
# cl_context : context
|
|
398
423
|
# cl_mem_flags : flags
|
|
399
424
|
# size_t : size
|
|
400
425
|
# void * : host_ptr
|
|
401
426
|
def createBuffer(context, flags, size, host_ptr = nil, error_info: nil)
|
|
427
|
+
context = context.handle if context.kind_of? CLUContext
|
|
402
428
|
errcode_ret_buf = ' ' * 4
|
|
403
429
|
|
|
404
430
|
mem = OpenCL.clCreateBuffer(context, flags, size, host_ptr, errcode_ret_buf)
|
|
@@ -425,6 +451,7 @@ class CLUMemory
|
|
|
425
451
|
# const cl_image_desc * : image_desc
|
|
426
452
|
# void * : host_ptr
|
|
427
453
|
def createImage(context, flags, image_format, image_desc, host_ptr = nil, error_info: nil)
|
|
454
|
+
context = context.handle if context.kind_of? CLUContext
|
|
428
455
|
errcode_ret_buf = ' ' * 4
|
|
429
456
|
|
|
430
457
|
mem = OpenCL.clCreateImage(context, flags, image_format, image_desc, host_ptr, errcode_ret_buf)
|
|
@@ -449,6 +476,7 @@ class CLUMemory
|
|
|
449
476
|
# cl_mem_flags : flags
|
|
450
477
|
# cl_GLuint : bufobj
|
|
451
478
|
def createFromGLBuffer(context, flags, bufobj, error_info: nil)
|
|
479
|
+
context = context.handle if context.kind_of? CLUContext
|
|
452
480
|
errcode_ret_buf = ' ' * 4
|
|
453
481
|
|
|
454
482
|
mem = OpenCL.clCreateFromGLBuffer(context, flags, bufobj, errcode_ret_buf)
|
|
@@ -475,6 +503,7 @@ class CLUMemory
|
|
|
475
503
|
# cl_GLint : miplevel
|
|
476
504
|
# cl_GLuint : texture
|
|
477
505
|
def createFromGLTexture(context, flags, target, miplevel, texture, error_info: nil)
|
|
506
|
+
context = context.handle if context.kind_of? CLUContext
|
|
478
507
|
errcode_ret_buf = ' ' * 4
|
|
479
508
|
|
|
480
509
|
mem = OpenCL.clCreateFromGLTexture(context, flags, target, miplevel, texture, errcode_ret_buf)
|
|
@@ -499,6 +528,7 @@ class CLUMemory
|
|
|
499
528
|
# cl_mem_flags : flags
|
|
500
529
|
# cl_GLuint : renderbuffer
|
|
501
530
|
def createFromGLRenderBuffer(context, flags, renderbuffer, error_info: nil)
|
|
531
|
+
context = context.handle if context.kind_of? CLUContext
|
|
502
532
|
errcode_ret_buf = ' ' * 4
|
|
503
533
|
|
|
504
534
|
mem = OpenCL.clCreateFromGLRenderBuffer(context, flags, renderbuffer, errcode_ret_buf)
|
|
@@ -524,11 +554,15 @@ class CLUMemory
|
|
|
524
554
|
return OpenCL.clRetainMemObject(mem)
|
|
525
555
|
end
|
|
526
556
|
|
|
557
|
+
alias_method :retain, :retainMemObject
|
|
558
|
+
|
|
527
559
|
# cl_mem : mem
|
|
528
560
|
def releaseMemObject(mem: @mem)
|
|
529
561
|
return OpenCL.clReleaseMemObject(mem)
|
|
530
562
|
end
|
|
531
563
|
|
|
564
|
+
alias_method :release, :releaseMemObject
|
|
565
|
+
|
|
532
566
|
# cl_mem : memobj
|
|
533
567
|
# cl_mem_info : param_name
|
|
534
568
|
def getMemObjectInfo(param_name, memobj: @mem, error_info: nil)
|
|
@@ -661,10 +695,15 @@ class CLUCommandQueue
|
|
|
661
695
|
@command_queue = nil # cl_command_queue
|
|
662
696
|
end
|
|
663
697
|
|
|
698
|
+
def handle
|
|
699
|
+
@command_queue
|
|
700
|
+
end
|
|
701
|
+
|
|
664
702
|
# cl_context : context
|
|
665
703
|
# cl_device_id : device
|
|
666
704
|
# cl_command_queue_properties : properties
|
|
667
705
|
def createCommandQueue(context, device, properties = 0, error_info: nil)
|
|
706
|
+
context = context.handle if context.kind_of? CLUContext
|
|
668
707
|
errcode_ret_buf = ' ' * 4
|
|
669
708
|
|
|
670
709
|
cl_cq = OpenCL.clCreateCommandQueue(context, device, properties, errcode_ret_buf)
|
|
@@ -690,11 +729,15 @@ class CLUCommandQueue
|
|
|
690
729
|
return OpenCL.clRetainCommandQueue(command_queue)
|
|
691
730
|
end
|
|
692
731
|
|
|
732
|
+
alias_method :retain, :retainCommandQueue
|
|
733
|
+
|
|
693
734
|
# cl_command_queue : command_queue
|
|
694
735
|
def releaseCommandQueue(command_queue: @command_queue)
|
|
695
736
|
return OpenCL.clReleaseCommandQueue(command_queue)
|
|
696
737
|
end
|
|
697
738
|
|
|
739
|
+
alias_method :release, :releaseCommandQueue
|
|
740
|
+
|
|
698
741
|
# cl_command_queue : command_queue
|
|
699
742
|
def flush(command_queue: @command_queue)
|
|
700
743
|
return OpenCL.clFlush(command_queue)
|
|
@@ -740,6 +783,7 @@ class CLUCommandQueue
|
|
|
740
783
|
# const cl_event * : event_wait_list
|
|
741
784
|
# cl_event * : event
|
|
742
785
|
def enqueueReadBuffer(buffer, blocking_read, offset, size, ptr, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
786
|
+
buffer = buffer.handle if buffer.kind_of? CLUMemory
|
|
743
787
|
event_buf = event == nil ? nil : ' ' * 8
|
|
744
788
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
745
789
|
|
|
@@ -759,6 +803,7 @@ class CLUCommandQueue
|
|
|
759
803
|
# const cl_event * : event_wait_list
|
|
760
804
|
# cl_event * : event
|
|
761
805
|
def enqueueWriteBuffer(buffer, blocking_write, offset, size, ptr, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
806
|
+
buffer = buffer.handle if buffer.kind_of? CLUMemory
|
|
762
807
|
event_buf = event == nil ? nil : ' ' * 8
|
|
763
808
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
764
809
|
|
|
@@ -777,6 +822,7 @@ class CLUCommandQueue
|
|
|
777
822
|
# const cl_event * : event_wait_list
|
|
778
823
|
# cl_event * : event
|
|
779
824
|
def enqueueFillBuffer(buffer, pattern, offset, size, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
825
|
+
buffer = buffer.handle if buffer.kind_of? CLUMemory
|
|
780
826
|
event_buf = event == nil ? nil : ' ' * 8
|
|
781
827
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
782
828
|
# size_t : pattern_size
|
|
@@ -798,6 +844,8 @@ class CLUCommandQueue
|
|
|
798
844
|
# const cl_event * : event_wait_list
|
|
799
845
|
# cl_event * : event
|
|
800
846
|
def enqueueCopyBuffer(src_buffer, dst_buffer, src_offset, dst_offset, size, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
847
|
+
src_buffer = src_buffer.handle if src_buffer.kind_of? CLUMemory
|
|
848
|
+
dst_buffer = dst_buffer.handle if dst_buffer.kind_of? CLUMemory
|
|
801
849
|
event_buf = event == nil ? nil : ' ' * 8
|
|
802
850
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
803
851
|
|
|
@@ -819,6 +867,7 @@ class CLUCommandQueue
|
|
|
819
867
|
# const cl_event * : event_wait_list
|
|
820
868
|
# cl_event * : event
|
|
821
869
|
def enqueueReadImage(image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
870
|
+
image = image.handle if image.kind_of? CLUMemory
|
|
822
871
|
event_buf = event == nil ? nil : ' ' * 8
|
|
823
872
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
824
873
|
|
|
@@ -840,6 +889,7 @@ class CLUCommandQueue
|
|
|
840
889
|
# const cl_event * : event_wait_list
|
|
841
890
|
# cl_event * : event
|
|
842
891
|
def enqueueWriteImage(image, blocking_write, origin, region, row_pitch, slice_pitch, ptr, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
892
|
+
image = image.handle if image.kind_of? CLUMemory
|
|
843
893
|
event_buf = event == nil ? nil : ' ' * 8
|
|
844
894
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
845
895
|
|
|
@@ -858,6 +908,7 @@ class CLUCommandQueue
|
|
|
858
908
|
# const cl_event * : event_wait_list
|
|
859
909
|
# cl_event * : event
|
|
860
910
|
def enqueueFillImage(image, fill_color, origin, region, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
911
|
+
image = image.handle if image.kind_of? CLUMemory
|
|
861
912
|
event_buf = event == nil ? nil : ' ' * 8
|
|
862
913
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
863
914
|
|
|
@@ -877,6 +928,8 @@ class CLUCommandQueue
|
|
|
877
928
|
# const cl_event * : event_wait_list
|
|
878
929
|
# cl_event * : event
|
|
879
930
|
def enqueueCopyImage(src_image, dst_image, src_origin, dst_origin, region, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
931
|
+
src_image = src_image.handle if src_image.kind_of? CLUMemory
|
|
932
|
+
dst_image = dst_image.handle if dst_image.kind_of? CLUMemory
|
|
880
933
|
event_buf = event == nil ? nil : ' ' * 8
|
|
881
934
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
882
935
|
|
|
@@ -896,6 +949,8 @@ class CLUCommandQueue
|
|
|
896
949
|
# const cl_event * : event_wait_list
|
|
897
950
|
# cl_event * : event
|
|
898
951
|
def enqueueCopyImageToBuffer(src_image, dst_buffer, src_origin, region, dst_offset, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
952
|
+
src_image = src_image.handle if src_image.kind_of? CLUMemory
|
|
953
|
+
dst_buffer = dst_buffer.handle if dst_buffer.kind_of? CLUMemory
|
|
899
954
|
event_buf = event == nil ? nil : ' ' * 8
|
|
900
955
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
901
956
|
|
|
@@ -915,6 +970,8 @@ class CLUCommandQueue
|
|
|
915
970
|
# const cl_event * : event_wait_list
|
|
916
971
|
# cl_event * : event
|
|
917
972
|
def enqueueCopyBufferToImage(src_buffer, dst_image, src_offset, dst_origin, region, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
973
|
+
src_buffer = src_buffer.handle if src_buffer.kind_of? CLUMemory
|
|
974
|
+
dst_image = dst_image.handle if dst_image.kind_of? CLUMemory
|
|
918
975
|
event_buf = event == nil ? nil : ' ' * 8
|
|
919
976
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
920
977
|
|
|
@@ -934,6 +991,7 @@ class CLUCommandQueue
|
|
|
934
991
|
# const cl_event * : event_wait_list
|
|
935
992
|
# cl_event * : event
|
|
936
993
|
def enqueueMapBuffer(buffer, blocking_map, map_flags, offset, size, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
994
|
+
buffer = buffer.handle if buffer.kind_of? CLUMemory
|
|
937
995
|
event_buf = event == nil ? nil : ' ' * 8
|
|
938
996
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
939
997
|
errcode_ret_buf = ' ' * 4
|
|
@@ -959,6 +1017,7 @@ class CLUCommandQueue
|
|
|
959
1017
|
# const cl_event * : event_wait_list
|
|
960
1018
|
# cl_event * : event
|
|
961
1019
|
def enqueueMapImage(buffer, blocking_map, map_flags, origin, region, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
1020
|
+
buffer = buffer.handle if buffer.kind_of? CLUMemory
|
|
962
1021
|
event_buf = event == nil ? nil : ' ' * 8
|
|
963
1022
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
964
1023
|
errcode_ret_buf = ' ' * 4
|
|
@@ -987,6 +1046,7 @@ class CLUCommandQueue
|
|
|
987
1046
|
# const cl_event * : event_wait_list
|
|
988
1047
|
# cl_event * : event
|
|
989
1048
|
def enqueueUnmapMemObject(memobj, mapped_ptr, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
1049
|
+
memobj = memobj.handle if memobj.kind_of? CLUMemory
|
|
990
1050
|
event_buf = event == nil ? nil : ' ' * 8
|
|
991
1051
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
992
1052
|
|
|
@@ -1006,6 +1066,7 @@ class CLUCommandQueue
|
|
|
1006
1066
|
# const cl_event * : event_wait_list
|
|
1007
1067
|
# cl_event * : event
|
|
1008
1068
|
def enqueueNDRangeKernel(kernel, work_dim, global_work_offset, global_work_size, local_work_size, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
1069
|
+
kernel = kernel.handle if kernel.kind_of? CLUKernel
|
|
1009
1070
|
event_buf = event == nil ? nil : ' ' * 8
|
|
1010
1071
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
1011
1072
|
|
|
@@ -1024,6 +1085,7 @@ class CLUCommandQueue
|
|
|
1024
1085
|
# const cl_event * : event_wait_list
|
|
1025
1086
|
# cl_event * : event
|
|
1026
1087
|
def enqueueTask(kernel, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
1088
|
+
kernel = kernel.handle if kernel.kind_of? CLUKernel
|
|
1027
1089
|
event_buf = event == nil ? nil : ' ' * 8
|
|
1028
1090
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
1029
1091
|
|
|
@@ -1039,6 +1101,7 @@ class CLUCommandQueue
|
|
|
1039
1101
|
# const cl_event * : event_wait_list
|
|
1040
1102
|
# cl_event * : event
|
|
1041
1103
|
def enqueueAcquireGLObjects(mem_objects, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
1104
|
+
mem_objects.collect! {|mem_object| mem_object.kind_of?(CLUMemory) ? mem_object.mem.to_i : mem_object}
|
|
1042
1105
|
event_buf = event == nil ? nil : ' ' * 8
|
|
1043
1106
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
1044
1107
|
|
|
@@ -1054,6 +1117,7 @@ class CLUCommandQueue
|
|
|
1054
1117
|
# const cl_event * : event_wait_list
|
|
1055
1118
|
# cl_event * : event
|
|
1056
1119
|
def enqueueReleaseGLObjects(mem_objects, command_queue: @command_queue, event_wait_list: nil, event: nil, error_info: nil)
|
|
1120
|
+
mem_objects.collect! {|mem_object| mem_object.kind_of?(CLUMemory) ? mem_object.mem.to_i : mem_object}
|
|
1057
1121
|
event_buf = event == nil ? nil : ' ' * 8
|
|
1058
1122
|
num_events_in_wait_list = event_wait_list == nil ? 0 : event_wait_list.length
|
|
1059
1123
|
|
|
@@ -1074,9 +1138,15 @@ class CLUProgram
|
|
|
1074
1138
|
@program = nil
|
|
1075
1139
|
end
|
|
1076
1140
|
|
|
1141
|
+
def handle
|
|
1142
|
+
@program
|
|
1143
|
+
end
|
|
1144
|
+
|
|
1077
1145
|
# cl_context : context
|
|
1078
1146
|
# const char ** : strings
|
|
1079
1147
|
def createProgramWithSource(context, strings, error_info: nil)
|
|
1148
|
+
context = context.handle if context.kind_of? CLUContext
|
|
1149
|
+
|
|
1080
1150
|
# cl_uint : count
|
|
1081
1151
|
# const size_t * : lengths
|
|
1082
1152
|
# cl_int * : errcode_ret
|
|
@@ -1107,11 +1177,15 @@ class CLUProgram
|
|
|
1107
1177
|
return OpenCL.clRetainProgram(program)
|
|
1108
1178
|
end
|
|
1109
1179
|
|
|
1180
|
+
alias_method :retain, :retainProgram
|
|
1181
|
+
|
|
1110
1182
|
# cl_program : program
|
|
1111
1183
|
def releaseProgram(program: @program)
|
|
1112
1184
|
return OpenCL.clReleaseProgram(program)
|
|
1113
1185
|
end
|
|
1114
1186
|
|
|
1187
|
+
alias_method :release, :releaseProgram
|
|
1188
|
+
|
|
1115
1189
|
# cl_program : program
|
|
1116
1190
|
# const cl_device_id * : device_list
|
|
1117
1191
|
# const char * : options
|
|
@@ -1122,13 +1196,15 @@ class CLUProgram
|
|
|
1122
1196
|
err = OpenCL.clBuildProgram(program, num_devices, device_list.pack("Q*"), options, pfn_notify, user_data)
|
|
1123
1197
|
|
|
1124
1198
|
if err < 0 && error_info != nil
|
|
1125
|
-
|
|
1126
|
-
|
|
1127
|
-
|
|
1128
|
-
|
|
1129
|
-
|
|
1130
|
-
|
|
1131
|
-
|
|
1199
|
+
num_devices.times do |i|
|
|
1200
|
+
log_size_buf = ' ' * 4
|
|
1201
|
+
OpenCL.clGetProgramBuildInfo(program, device_list[0], OpenCL::CL_PROGRAM_BUILD_LOG, 0, nil, log_size_buf)
|
|
1202
|
+
log_size = log_size_buf.unpack("L")[0]
|
|
1203
|
+
program_log = ' ' * log_size
|
|
1204
|
+
OpenCL.clGetProgramBuildInfo(program, device_list[0], OpenCL::CL_PROGRAM_BUILD_LOG, log_size, program_log, nil)
|
|
1205
|
+
|
|
1206
|
+
error_info << program_log
|
|
1207
|
+
end
|
|
1132
1208
|
end
|
|
1133
1209
|
|
|
1134
1210
|
return err
|
|
@@ -1145,9 +1221,14 @@ class CLUKernel
|
|
|
1145
1221
|
@name = nil
|
|
1146
1222
|
end
|
|
1147
1223
|
|
|
1224
|
+
def handle
|
|
1225
|
+
@kernel
|
|
1226
|
+
end
|
|
1227
|
+
|
|
1148
1228
|
# cl_program : program
|
|
1149
1229
|
# const char * : kernel_name
|
|
1150
1230
|
def createKernel(program, kernel_name, error_info: nil)
|
|
1231
|
+
program = program.handle if program.kind_of? CLUProgram
|
|
1151
1232
|
errcode_ret_buf = ' ' * 4
|
|
1152
1233
|
kernel = OpenCL.clCreateKernel(program, kernel_name, errcode_ret_buf)
|
|
1153
1234
|
errcode_ret = errcode_ret_buf.unpack("l")[0]
|
|
@@ -1206,11 +1287,15 @@ class CLUKernel
|
|
|
1206
1287
|
return OpenCL.clRetainKernel(kernel)
|
|
1207
1288
|
end
|
|
1208
1289
|
|
|
1290
|
+
alias_method :retain, :retainKernel
|
|
1291
|
+
|
|
1209
1292
|
# cl_kernel : kernel
|
|
1210
1293
|
def releaseKernel(kernel: @kernel)
|
|
1211
1294
|
return OpenCL.clReleaseKernel(kernel)
|
|
1212
1295
|
end
|
|
1213
1296
|
|
|
1297
|
+
alias_method :release, :releaseKernel
|
|
1298
|
+
|
|
1214
1299
|
def sizeof_type(fiddle_type)
|
|
1215
1300
|
size = 0
|
|
1216
1301
|
|
|
@@ -1316,9 +1401,19 @@ class CLUKernel
|
|
|
1316
1401
|
def setKernelArg(arg_index, arg_type, arg_value, kernel: @kernel)
|
|
1317
1402
|
num_elements = arg_value.length
|
|
1318
1403
|
arg_size = sizeof_type(arg_type) * num_elements
|
|
1319
|
-
|
|
1404
|
+
packed_arg_value = nil
|
|
1405
|
+
if arg_value != nil
|
|
1406
|
+
pack_arg = pack_format(arg_type) + num_elements.to_s
|
|
1407
|
+
packed_arg_value = arg_value.pack(pack_arg)
|
|
1408
|
+
end
|
|
1409
|
+
return OpenCL.clSetKernelArg(kernel, arg_index, arg_size, packed_arg_value)
|
|
1410
|
+
end
|
|
1320
1411
|
|
|
1321
|
-
|
|
1412
|
+
# cl_kernel : kernel
|
|
1413
|
+
# cl_uint : arg_index
|
|
1414
|
+
# size_t : arg_size
|
|
1415
|
+
def setLocalKernelArg(arg_index, arg_size, kernel: @kernel)
|
|
1416
|
+
return OpenCL.clSetKernelArg(kernel, arg_index, arg_size, nil)
|
|
1322
1417
|
end
|
|
1323
1418
|
|
|
1324
1419
|
# cl_kernel : kernel
|
|
@@ -1332,6 +1427,12 @@ class CLUKernel
|
|
|
1332
1427
|
param_value_buf = ' ' * param_value_buf_length
|
|
1333
1428
|
param_value_size_ret_buf = ' ' * 4
|
|
1334
1429
|
|
|
1430
|
+
# Ref.: https://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/clGetKernelArgInfo.html
|
|
1431
|
+
#
|
|
1432
|
+
# Notes : Kernel argument information is only available if the program
|
|
1433
|
+
# object associated with kernel is created with clCreateProgramWithSource
|
|
1434
|
+
# and the program executable is built with the -cl-kernel-arg-info option
|
|
1435
|
+
# specified in options argument to clBuildProgram or clCompileProgram.
|
|
1335
1436
|
err = OpenCL.clGetKernelArgInfo(kernel, arg_index, param_name, param_value_buf_length, param_value_buf, param_value_size_ret_buf)
|
|
1336
1437
|
error_info << err if error_info != nil
|
|
1337
1438
|
param_value_size_ret = param_value_size_ret_buf.unpack("L")[0]
|
metadata
CHANGED
|
@@ -1,14 +1,14 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: opencl-bindings
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 1.0.
|
|
4
|
+
version: 1.0.0pre2
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- vaiorabbit
|
|
8
8
|
autorequire:
|
|
9
9
|
bindir: bin
|
|
10
10
|
cert_chain: []
|
|
11
|
-
date: 2015-11-
|
|
11
|
+
date: 2015-11-23 00:00:00.000000000 Z
|
|
12
12
|
dependencies: []
|
|
13
13
|
description: |
|
|
14
14
|
Ruby bindings for OpenCL 1.2 using Fiddle (For MRI >= 2.0.0).
|
|
@@ -28,6 +28,7 @@ files:
|
|
|
28
28
|
- sample/hello.cl
|
|
29
29
|
- sample/hello.rb
|
|
30
30
|
- sample/hello_clu.rb
|
|
31
|
+
- sample/report_env.rb
|
|
31
32
|
- sample/util/clu.rb
|
|
32
33
|
homepage: https://github.com/vaiorabbit/ruby-opencl
|
|
33
34
|
licenses:
|