opencl_ruby_ffi 1.2.2 → 1.3.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (45) hide show
  1. checksums.yaml +4 -4
  2. data/.yardopts +1 -0
  3. data/lib/opencl_ruby_ffi.rb +2 -0
  4. data/lib/opencl_ruby_ffi/Buffer.rb +18 -13
  5. data/lib/opencl_ruby_ffi/CommandQueue.rb +301 -302
  6. data/lib/opencl_ruby_ffi/Context.rb +158 -158
  7. data/lib/opencl_ruby_ffi/Device.rb +270 -224
  8. data/lib/opencl_ruby_ffi/Event.rb +40 -36
  9. data/lib/opencl_ruby_ffi/Image.rb +34 -57
  10. data/lib/opencl_ruby_ffi/Kernel.rb +251 -191
  11. data/lib/opencl_ruby_ffi/Mem.rb +49 -70
  12. data/lib/opencl_ruby_ffi/Pipe.rb +3 -14
  13. data/lib/opencl_ruby_ffi/Platform.rb +46 -48
  14. data/lib/opencl_ruby_ffi/Program.rb +131 -124
  15. data/lib/opencl_ruby_ffi/Sampler.rb +6 -24
  16. data/lib/opencl_ruby_ffi/amd/device_attribute_query.rb +100 -0
  17. data/lib/opencl_ruby_ffi/egl.rb +2 -0
  18. data/lib/opencl_ruby_ffi/ext.rb +11 -0
  19. data/lib/opencl_ruby_ffi/ext/device_fission.rb +264 -0
  20. data/lib/opencl_ruby_ffi/gl_ext.rb +2 -0
  21. data/lib/opencl_ruby_ffi/khr/d3d10_sharing.rb +120 -0
  22. data/lib/opencl_ruby_ffi/khr/d3d11_sharing.rb +120 -0
  23. data/lib/opencl_ruby_ffi/khr/dx9_media_sharing.rb +113 -0
  24. data/lib/opencl_ruby_ffi/khr/egl_event.rb +15 -0
  25. data/lib/opencl_ruby_ffi/khr/egl_image.rb +58 -0
  26. data/lib/opencl_ruby_ffi/khr/fp16.rb +23 -0
  27. data/lib/opencl_ruby_ffi/khr/fp64.rb +23 -0
  28. data/lib/opencl_ruby_ffi/khr/gl_event.rb +38 -0
  29. data/lib/opencl_ruby_ffi/khr/gl_sharing.rb +79 -0
  30. data/lib/opencl_ruby_ffi/khr/icd.rb +30 -0
  31. data/lib/opencl_ruby_ffi/khr/initalize_memory.rb +19 -0
  32. data/lib/opencl_ruby_ffi/khr/priority_hints.rb +48 -0
  33. data/lib/opencl_ruby_ffi/khr/spir.rb +45 -0
  34. data/lib/opencl_ruby_ffi/khr/sub_groups.rb +49 -0
  35. data/lib/opencl_ruby_ffi/khr/terminate_context.rb +46 -0
  36. data/lib/opencl_ruby_ffi/khr/throttle_hints.rb +47 -0
  37. data/lib/opencl_ruby_ffi/nv/device_attribute_query.rb +50 -0
  38. data/lib/opencl_ruby_ffi/opencl_ruby_ffi_base.rb +40 -13
  39. data/lib/opencl_ruby_ffi/opencl_ruby_ffi_base_gen.rb +214 -2114
  40. data/lib/opencl_ruby_ffi/opencl_types.rb +15 -3
  41. data/opencl_ruby_ffi.gemspec +4 -4
  42. data/templates_custom/default/module/setup.rb +9 -0
  43. metadata +29 -6
  44. data/lib/opencl_ruby_ffi/GLExt.rb +0 -58
  45. data/lib/opencl_ruby_ffi/Stream.rb +0 -127
@@ -22,16 +22,20 @@ module OpenCL
22
22
  # Maps the cl_mem object of OpenCL
23
23
  class Mem
24
24
  include InnerInterface
25
-
26
- class << self
27
- include InnerGenerator
28
- end
25
+ extend InnerGenerator
29
26
 
30
27
  def inspect
31
28
  f = flags
32
29
  return "#<#{self.class.name}: #{size}#{ 0 != f.to_i ? " (#{f})" : ""}>"
33
30
  end
34
31
 
32
+ get_info("Mem", :cl_mem_object_type, "type")
33
+ get_info("Mem", :cl_mem_flags, "flags")
34
+ get_info("Mem", :size_t, "size")
35
+ get_info("Mem", :pointer, "host_ptr")
36
+ get_info("Mem", :cl_uint, "map_count")
37
+ get_info("Mem", :cl_uint, "reference_count")
38
+
35
39
  # Returns the Context associated to the Mem
36
40
  def context
37
41
  ptr = MemoryPointer::new( Context )
@@ -45,72 +49,6 @@ module OpenCL
45
49
  return self.context.platform
46
50
  end
47
51
 
48
- # Returns the Buffer this Buffer was created from using create_sub_buffer
49
- def associated_memobject
50
- ptr = MemoryPointer::new( Mem )
51
- error = OpenCL.clGetMemObjectInfo(self, ASSOCIATED_MEMOBJECT, Mem.size, ptr, nil)
52
- error_check(error)
53
- return nil if ptr.read_pointer.null?
54
- return Mem::new( ptr.read_pointer )
55
- end
56
-
57
- ##
58
- # :method: offset()
59
- # Returns the offset used to create this Buffer using create_sub_buffer
60
-
61
- ##
62
- # :method: size()
63
- # Returns the size of the Buffer
64
- %w( OFFSET SIZE ).each { |prop|
65
- eval get_info("Mem", :size_t, prop)
66
- }
67
-
68
- ##
69
- # :method: map_count()
70
- # Returns the number of times this Mem is mapped
71
-
72
- ##
73
- # :method: reference_count()
74
- # Returns the Mem reference counter
75
- %w( MAP_COUNT REFERENCE_COUNT ).each { |prop|
76
- eval get_info("Mem", :cl_uint, prop)
77
- }
78
-
79
- ##
80
- # :method: uses_svn_pointer()
81
- # Returns true if Mem uses an SVM pointer
82
- eval get_info("Mem", :cl_bool, "USES_SVM_POINTER")
83
-
84
- ##
85
- # :method: type()
86
- # Returns a Mem::Type corresponding to the Mem
87
- eval get_info("Mem", :cl_mem_object_type, "TYPE")
88
-
89
- ##
90
- # :method: flags()
91
- # Returns a Mem::Flags corresponding to the flags used at Mem creation
92
- eval get_info("Mem", :cl_mem_flags, "FLAGS")
93
-
94
- ##
95
- # :method: host_ptr()
96
- # Returns the host Pointer specified at Mem creation or the pointer + the ofsset if it is a sub-buffer. A null Pointer is returned otherwise.
97
- eval get_info("Mem", :pointer, "HOST_PTR")
98
-
99
- # Attaches a callback to memobj that will be called on the memobj destruction
100
- #
101
- # ==== Attributes
102
- #
103
- # * +options+ - a hash containing named options
104
- # * +block+ - if provided, a callback invoked when memobj is released. Signature of the callback is { |Mem, Pointer to user_data| ... }
105
- #
106
- # ==== Options
107
- #
108
- # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
109
- def set_destructor_callback( options = {}, &proc )
110
- OpenCL.set_mem_object_destructor_callback( self, options, &proc )
111
- return self
112
- end
113
-
114
52
  # Returns the texture_target argument specified in create_from_GL_texture for Mem
115
53
  def gl_texture_target
116
54
  param_value = MemoryPointer::new( :cl_GLenum )
@@ -147,6 +85,47 @@ module OpenCL
147
85
  end
148
86
  alias :GL_object_name :gl_object_name
149
87
 
88
+ module OpenCL11
89
+ extend InnerGenerator
90
+
91
+ get_info("Mem", :size_t, "offset")
92
+
93
+ # Returns the Buffer this Buffer was created from using create_sub_buffer
94
+ def associated_memobject
95
+ ptr = MemoryPointer::new( Mem )
96
+ error = OpenCL.clGetMemObjectInfo(self, ASSOCIATED_MEMOBJECT, Mem.size, ptr, nil)
97
+ error_check(error)
98
+ return nil if ptr.read_pointer.null?
99
+ return Mem::new( ptr.read_pointer )
100
+ end
101
+
102
+ # Attaches a callback to memobj that will be called on the memobj destruction
103
+ #
104
+ # ==== Attributes
105
+ #
106
+ # * +options+ - a hash containing named options
107
+ # * +block+ - if provided, a callback invoked when memobj is released. Signature of the callback is { |Mem, Pointer to user_data| ... }
108
+ #
109
+ # ==== Options
110
+ #
111
+ # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
112
+ def set_destructor_callback( options = {}, &proc )
113
+ OpenCL.set_mem_object_destructor_callback( self, options, &proc )
114
+ return self
115
+ end
116
+
117
+ end
118
+
119
+ module OpenCL20
120
+ extend InnerGenerator
121
+
122
+ get_info("Mem", :cl_bool, "uses_svm_pointer")
123
+
124
+ end
125
+
126
+ register_extension( :v11, OpenCL11, "platform.version_number >= 1.1" )
127
+ register_extension( :v20, OpenCL20, "platform.version_number >= 2.0" )
128
+
150
129
  end
151
130
 
152
131
  end
@@ -24,26 +24,15 @@ module OpenCL
24
24
  # Maps the cl_mem OpenCL objects of type CL_MEM_OBJECT_PIPE
25
25
  class Pipe #< Mem
26
26
  include InnerInterface
27
-
28
- class << self
29
- include InnerGenerator
30
- end
27
+ extend InnerGenerator
31
28
 
32
29
  def inspect
33
30
  f = flags
34
31
  return "#<#{self.class.inspect}: #{packet_size}x#{max_packets}#{ 0 != f.to_i ? " (#{f})" : ""}>"
35
32
  end
36
33
 
37
- ##
38
- # :method: packet_size
39
- # Returns the packet_size of the Pipe
40
-
41
- ##
42
- # :method: max_packets
43
- # Returns the max_packets of the Pipe
44
- %w( PACKET_SIZE MAX_PACKETS ).each { |prop|
45
- eval get_info("Pipe", :cl_uint, prop)
46
- }
34
+ get_info("Pipe", :cl_uint, "packet_size")
35
+ get_info("Pipe", :cl_uint, "max_packets")
47
36
 
48
37
  end
49
38
 
@@ -35,6 +35,15 @@ module OpenCL
35
35
  return Function::new(return_type, param_types, ptr, options)
36
36
  end
37
37
 
38
+ def self.attach_extension_function( name, return_type, param_types, options = {} )
39
+ f = get_extension_function( name, return_type, param_types, options )
40
+ if not f then
41
+ warn "Warning: could not find extension function #{name}!"
42
+ return nil
43
+ end
44
+ f.attach(OpenCL, name)
45
+ end
46
+
38
47
  # Returns a Function corresponding to an extension function for the Platform
39
48
  #
40
49
  # ==== Attributes
@@ -73,42 +82,17 @@ module OpenCL
73
82
  # Maps the cl_platform_id object of OpenCL
74
83
  class Platform
75
84
  include InnerInterface
76
-
77
- class << self
78
- include InnerGenerator
79
- end
85
+ extend InnerGenerator
80
86
 
81
87
  def inspect
82
88
  return "#<#{self.class.name}: #{self.name}>"
83
89
  end
84
90
 
85
- ##
86
- # :method: icd_suffix_khr()
87
- # Returns a String containing the function name suffix used to identify extension functions to be directed to this platform by the ICD Loader
88
-
89
- ##
90
- # :method: profile()
91
- # Returns a String containing the profile name supported by the Platform
92
-
93
- ##
94
- # :method: version()
95
- # Returns a String containing the version number
96
-
97
- ##
98
- # :method: name()
99
- # Returns a String containing the Platform name
100
-
101
- ##
102
- # :method: vendor()
103
- # Returns a String identifying the Platform vendor
104
- %w(PROFILE VERSION NAME VENDOR ICD_SUFFIX_KHR).each { |prop|
105
- eval get_info("Platform", :string, prop)
106
- }
107
-
108
- ##
109
- # :method: host_timer_resolution()
110
- # returns the host timer resulution in nanoseconds
111
- eval get_info("Platform", :cl_ulong, "HOST_TIMER_RESOLUTION")
91
+ get_info("Platform", :string, "profile")
92
+ get_info("Platform", :string, "version")
93
+ get_info("Platform", :string, "name")
94
+ alias to_s name
95
+ get_info("Platform", :string, "vendor")
112
96
 
113
97
  # Returns an Array of string corresponding to the Platform extensions
114
98
  def extensions
@@ -143,23 +127,6 @@ module OpenCL
143
127
  return n.first.first.to_f
144
128
  end
145
129
 
146
- # Unloads the Platform compiler
147
- def unload_compiler
148
- return OpenCL.unload_platform_compiler(self)
149
- end
150
-
151
- # Returns a Function corresponding to an extension function for a Platform
152
- #
153
- # ==== Attributes
154
- #
155
- # * +name+ - a String representing the name of the function
156
- # * +return_type+ - the type of data returned by the function
157
- # * +param_types+ - an Array of types, corresponding to the parameters type
158
- # * +options+ - if given, a hash of named options that will be given to Function::new. See FFI doc for details.
159
- def get_extension_function( name, return_type, param_types, options = {} )
160
- return OpenCL.get_extension_function_for_platform( self, name, return_type, param_types, options )
161
- end
162
-
163
130
  # Creates a Context gathering devices of a certain type and belonging to this Platform
164
131
  #
165
132
  # ==== Attributes
@@ -184,6 +151,37 @@ module OpenCL
184
151
  OpenCL.create_context_from_type(type, opts, &block)
185
152
  end
186
153
 
154
+ module OpenCL12
155
+
156
+ # Returns a Function corresponding to an extension function for a Platform
157
+ #
158
+ # ==== Attributes
159
+ #
160
+ # * +name+ - a String representing the name of the function
161
+ # * +return_type+ - the type of data returned by the function
162
+ # * +param_types+ - an Array of types, corresponding to the parameters type
163
+ # * +options+ - if given, a hash of named options that will be given to Function::new. See FFI doc for details.
164
+ def get_extension_function( name, return_type, param_types, options = {} )
165
+ return OpenCL.get_extension_function_for_platform( self, name, return_type, param_types, options )
166
+ end
167
+
168
+ # Unloads the Platform compiler
169
+ def unload_compiler
170
+ return OpenCL.unload_platform_compiler(self)
171
+ end
172
+
173
+ end
174
+
175
+ module OpenCL21
176
+ extend InnerGenerator
177
+
178
+ get_info("Platform", :cl_ulong, "host_timer_resolution")
179
+
180
+ end
181
+
182
+ register_extension( :v12, OpenCL12, "version_number >= 1.2" )
183
+ register_extension( :v21, OpenCL21, "version_number >= 2.1" )
184
+
187
185
  end
188
186
 
189
187
  end
@@ -179,7 +179,7 @@ module OpenCL
179
179
  c_strs_length = MemoryPointer::new( :size_t, c_strs_p.size )
180
180
  c_strs_p.each_with_index { |p, i|
181
181
  c_strs[i].write_pointer(p)
182
- c_strs_length[i].write_size_t(p.size)
182
+ c_strs_length[i].write_size_t(p.size == 0 ? 0 : p.size - 1) # minus the null character
183
183
  }
184
184
  error = MemoryPointer::new( :cl_int )
185
185
  program_ptr = clCreateProgramWithSource(context, c_strs_p.size, c_strs, c_strs_length, error)
@@ -207,10 +207,7 @@ module OpenCL
207
207
  # Maps the cl_program object of OpenCL
208
208
  class Program
209
209
  include InnerInterface
210
-
211
- class << self
212
- include InnerGenerator
213
- end
210
+ extend InnerGenerator
214
211
 
215
212
  def inspect
216
213
  success = false
@@ -239,41 +236,50 @@ module OpenCL
239
236
  end
240
237
  end
241
238
 
242
- # Returns an Array containing the sizes of the binary inside the Program for each device
243
- eval get_info_array("Program", :size_t, "BINARY_SIZES")
239
+ # Returns the Context the Program is associated to
240
+ def context
241
+ ptr = MemoryPointer::new( Context )
242
+ error = OpenCL.clGetProgramInfo(self, CONTEXT, Context.size, ptr, nil)
243
+ error_check(error)
244
+ return Context::new( ptr.read_pointer )
245
+ end
244
246
 
245
- # Returns the number of Kernels defined in the Program
246
- eval get_info("Program", :size_t, "NUM_KERNELS")
247
+ get_info("Program", :cl_uint, "num_devices")
248
+ get_info("Program", :cl_uint, "reference_count")
247
249
 
248
- # Returns an Array of String representing the Kernel names inside the Program
249
- def kernel_names
250
- if context.platform.version_number < 1.2 then
251
- return kernels.collect(&:name)
252
- else
253
- kernel_names_size = MemoryPointer::new( :size_t )
254
- error = OpenCL.clGetProgramInfo( self, KERNEL_NAMES, 0, nil, kernel_names_size)
255
- error_check(error)
256
- k_names = MemoryPointer::new( kernel_names_size.read_size_t )
257
- error = OpenCL.clGetProgramInfo( self, KERNEL_NAMES, kernel_names_size.read_size_t, k_names, nil)
258
- error_check(error)
259
- k_names_string = k_names.read_string
260
- return k_names_string.split(";")
261
- end
250
+ # Returns the Array of Device the Program is associated with
251
+ def devices
252
+ n = self.num_devices
253
+ ptr2 = MemoryPointer::new( Device, n )
254
+ error = OpenCL.clGetProgramInfo(self, DEVICES, Device.size*n, ptr2, nil)
255
+ error_check(error)
256
+ return ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
257
+ Device::new(device_ptr)
258
+ }
262
259
  end
263
260
 
264
- # Returns the concatenated Program sources
265
- eval get_info("Program", :string, "SOURCE")
261
+ get_info("Program", :string, "source")
262
+ get_info_array("Program", :size_t, "binary_sizes")
266
263
 
267
- # Returns the total amount in byte used by the Program variables in the global address space for the Device(s) specified. Returns an Array of tuple [ Device, size ] (2.0 only)
268
- def build_global_variable_total_size(devs = nil)
269
- devs = self.devices if not devs
270
- devs = [devs].flatten
271
- ptr = MemoryPointer::new( :size_t )
272
- return devs.collect { |dev|
273
- error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_GLOBAL_VARIABLE_TOTAL_SIZE, ptr.size, ptr, nil)
274
- error_check(error)
275
- [dev, ptr.read_size_t]
264
+ # Returns the binaries associated to the Program for each Device. Returns an Array of tuple [ Device, String ]
265
+ def binaries
266
+ sizes = self.binary_sizes
267
+ bin_array = MemoryPointer::new( :pointer, sizes.length )
268
+ total_size = 0
269
+ pointers = []
270
+ sizes.each_with_index { |s, i|
271
+ total_size += s
272
+ pointers[i] = MemoryPointer::new(s)
273
+ bin_array[i].write_pointer(pointers[i])
276
274
  }
275
+ error = OpenCL.clGetProgramInfo(self, BINARIES, total_size, bin_array, nil)
276
+ error_check(error)
277
+ bins = []
278
+ devs = self.devices
279
+ sizes.each_with_index { |s, i|
280
+ bins.push [devs[i], pointers[i].read_bytes(s)]
281
+ }
282
+ return bins
277
283
  end
278
284
 
279
285
  # Returns the BuildStatus of the Program for each device associated to the Program or the Device(s) specified. Returns an Array of tuple [ Device, BuildStatus ]
@@ -288,18 +294,6 @@ module OpenCL
288
294
  }
289
295
  end
290
296
 
291
- # Returns the BinaryType for each Device associated to the Program or the Device(s) specified. Returns an Array of tuple [ Device, BinaryType ]
292
- def binary_type(devs = nil)
293
- devs = self.devices if not devs
294
- devs = [devs].flatten
295
- ptr = MemoryPointer::new( :cl_program_binary_type )
296
- return devs.collect { |dev|
297
- error = OpenCL.clGetProgramBuildInfo(self, dev, BINARY_TYPE, ptr.size, ptr, nil)
298
- error_check(error)
299
- [dev, BinaryType::new(ptr.read_cl_program_binary_type)]
300
- }
301
- end
302
-
303
297
  # Returns the build options for each Device associated to the Program or the Device(s) specified. Returns an Array of tuple [ Device, String ]
304
298
  def build_options(devs = nil)
305
299
  devs = self.devices if not devs
@@ -330,39 +324,6 @@ module OpenCL
330
324
  }
331
325
  end
332
326
 
333
- # Returns the binaries associated to the Program for each Device. Returns an Array of tuple [ Device, String ]
334
- def binaries
335
- sizes = self.binary_sizes
336
- bin_array = MemoryPointer::new( :pointer, sizes.length )
337
- sizes.length
338
- total_size = 0
339
- sizes.each_with_index { |s, i|
340
- total_size += s
341
- bin_array[i].write_pointer(MemoryPointer::new(s))
342
- }
343
- error = OpenCL.clGetProgramInfo(self, BINARIES, total_size, bin_array, nil)
344
- error_check(error)
345
- bins = []
346
- devs = self.devices
347
- sizes.each_with_index { |s, i|
348
- bins.push [devs, bin_array[i].read_pointer.read_bytes(s)]
349
- }
350
- return bins
351
- end
352
-
353
- # Return the intermediate level representation of the program if any, nil otherwise
354
- def il
355
- il_size = MemoryPointer::new( :size_t )
356
- error = OpenCL.clGetProgramInfo(self, IL, 0, nil, il_size)
357
- error_check(error)
358
- return nil if il_size == 0
359
- length = il_size.read_size_t
360
- il_p = MemoryPointer::new( length )
361
- error = OpenCL.clGetProgramInfo(self, IL, length, il_p, nil)
362
- error_check(error)
363
- return il_p.read_bytes(length)
364
- end
365
-
366
327
  # Builds (compile and link) the Program created from sources or binary
367
328
  #
368
329
  # ==== Attributes
@@ -378,63 +339,109 @@ module OpenCL
378
339
  OpenCL.build_program(self, options, &block)
379
340
  end
380
341
 
381
- # Compiles the Program' sources
382
- #
383
- # ==== Attributes
384
- #
385
- # * +options+ - a Hash containing named options
386
- # * +block+ - if provided, a callback invoked when the Program is compiled. Signature of the callback is { |Program, Pointer to user_data| ... }
387
- #
388
- # ==== Options
389
- #
390
- # * +:device_list+ - an Array of Device to build the program for
391
- # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
392
- # * +:options+ - a String containing the options to use for the compilation
393
- # * +:input_headers+ - a Hash containing pairs of : String: header_include_name => Program: header
394
- def compile(options = {}, &block)
395
- return OpenCL.compile_program(self, options, &block)
342
+ # Returns the Kernel corresponding the the specified name in the Program
343
+ def create_kernel( name )
344
+ return OpenCL.create_kernel( self, name )
396
345
  end
397
346
 
398
- # Returns the Context the Program is associated to
399
- def context
400
- ptr = MemoryPointer::new( Context )
401
- error = OpenCL.clGetProgramInfo(self, CONTEXT, Context.size, ptr, nil)
402
- error_check(error)
403
- return Context::new( ptr.read_pointer )
347
+ # Returns an Array of Kernel corresponding to the kernels defined inside the Program
348
+ def kernels
349
+ return OpenCL.create_kernels_in_program( self )
350
+ end
351
+
352
+ def kernel_names
353
+ return kernels.collect(&:name)
404
354
  end
405
355
 
406
- ##
407
- # :method: num_devices()
408
- # Returns the number of device this Program is associated with
356
+ module OpenCL12
357
+ extend InnerGenerator
358
+
359
+ get_info("Program", :size_t, "num_kernels")
360
+
361
+ # Returns an Array of String representing the Kernel names inside the Program
362
+ def kernel_names
363
+ if context.platform.version_number < 1.2 then
364
+ return kernels.collect(&:name)
365
+ else
366
+ kernel_names_size = MemoryPointer::new( :size_t )
367
+ error = OpenCL.clGetProgramInfo( self, KERNEL_NAMES, 0, nil, kernel_names_size)
368
+ error_check(error)
369
+ k_names = MemoryPointer::new( kernel_names_size.read_size_t )
370
+ error = OpenCL.clGetProgramInfo( self, KERNEL_NAMES, kernel_names_size.read_size_t, k_names, nil)
371
+ error_check(error)
372
+ k_names_string = k_names.read_string
373
+ return k_names_string.split(";")
374
+ end
375
+ end
409
376
 
410
- ##
411
- # :method: reference_count()
412
- # Returns the reference counter for this Program
413
- %w( NUM_DEVICES REFERENCE_COUNT ).each { |prop|
414
- eval get_info("Program", :cl_uint, prop)
415
- }
377
+ # Returns the BinaryType for each Device associated to the Program or the Device(s) specified. Returns an Array of tuple [ Device, BinaryType ]
378
+ def binary_type(devs = nil)
379
+ devs = self.devices if not devs
380
+ devs = [devs].flatten
381
+ ptr = MemoryPointer::new( :cl_program_binary_type )
382
+ return devs.collect { |dev|
383
+ error = OpenCL.clGetProgramBuildInfo(self, dev, BINARY_TYPE, ptr.size, ptr, nil)
384
+ error_check(error)
385
+ [dev, BinaryType::new(ptr.read_cl_program_binary_type)]
386
+ }
387
+ end
388
+
389
+ # Compiles the Program' sources
390
+ #
391
+ # ==== Attributes
392
+ #
393
+ # * +options+ - a Hash containing named options
394
+ # * +block+ - if provided, a callback invoked when the Program is compiled. Signature of the callback is { |Program, Pointer to user_data| ... }
395
+ #
396
+ # ==== Options
397
+ #
398
+ # * +:device_list+ - an Array of Device to build the program for
399
+ # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
400
+ # * +:options+ - a String containing the options to use for the compilation
401
+ # * +:input_headers+ - a Hash containing pairs of : String: header_include_name => Program: header
402
+ def compile(options = {}, &block)
403
+ return OpenCL.compile_program(self, options, &block)
404
+ end
416
405
 
417
- # Returns the Array of Device the Program is associated with
418
- def devices
419
- n = self.num_devices
420
- ptr2 = MemoryPointer::new( Device, n )
421
- error = OpenCL.clGetProgramInfo(self, DEVICES, Device.size*n, ptr2, nil)
422
- error_check(error)
423
- return ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
424
- Device::new(device_ptr)
425
- }
426
406
  end
427
407
 
428
- # Returns the Kernel corresponding the the specified name in the Program
429
- def create_kernel( name )
430
- return OpenCL.create_kernel( self, name )
408
+ module OpenCL20
409
+
410
+ # Returns the total amount in byte used by the Program variables in the global address space for the Device(s) specified. Returns an Array of tuple [ Device, size ] (2.0 only)
411
+ def build_global_variable_total_size(devs = nil)
412
+ devs = self.devices if not devs
413
+ devs = [devs].flatten
414
+ ptr = MemoryPointer::new( :size_t )
415
+ return devs.collect { |dev|
416
+ error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_GLOBAL_VARIABLE_TOTAL_SIZE, ptr.size, ptr, nil)
417
+ error_check(error)
418
+ [dev, ptr.read_size_t]
419
+ }
420
+ end
421
+
431
422
  end
432
423
 
433
- # Returns an Array of Kernel corresponding to the kernels defined inside the Program
434
- def kernels
435
- return OpenCL.create_kernels_in_program( self )
424
+ module OpenCL21
425
+
426
+ # Return the intermediate level representation of the program if any, nil otherwise
427
+ def il
428
+ il_size = MemoryPointer::new( :size_t )
429
+ error = OpenCL.clGetProgramInfo(self, IL, 0, nil, il_size)
430
+ error_check(error)
431
+ return nil if il_size == 0
432
+ length = il_size.read_size_t
433
+ il_p = MemoryPointer::new( length )
434
+ error = OpenCL.clGetProgramInfo(self, IL, length, il_p, nil)
435
+ error_check(error)
436
+ return il_p.read_bytes(length)
437
+ end
438
+
436
439
  end
437
440
 
441
+ register_extension( :v12, OpenCL12, "context.platform.version_number >= 1.2" )
442
+ register_extension( :v20, OpenCL20, "context.platform.version_number >= 2.0" )
443
+ register_extension( :v21, OpenCL21, "context.platform.version_number >= 2.1" )
444
+
438
445
  end
439
446
 
440
447
  end