opencl-bindings 1.0.0pre → 1.0.0pre2
Sign up to get free protection for your applications and to get access to all the features.
- 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:
|