Module: OpenCL::Device::OpenCL12

Included in:
OpenCL::Device
Defined in:
lib/opencl_ruby_ffi/Device.rb

Instance Method Summary collapse

Instance Method Details

#built_in_kernels ⇒ Object

Returns an Array of String corresponding to the Device built in kernel names



168
169
170
171
172
173
174
175
176
177
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 168

def built_in_kernels
  built_in_kernels_size = MemoryPointer::new( :size_t )
  error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS, 0, nil, built_in_kernels_size)
  error_check(error)
  ker = MemoryPointer::new( built_in_kernels_size.read_size_t )
  error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS, built_in_kernels_size.read_size_t, ker, nil)
  error_check(error)
  ker_string = ker.read_string
  return ker_string.split(";")
end

#create_sub_devices(properties) ⇒ Object

Partitions the Device in serveral sub-devices

Attributes

  • properties - an Array of :cl_device_partition_property

Returns

an Array of Device



267
268
269
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 267

def create_sub_devices( properties )
  return OpenCL.create_sub_devices( self, properties )
end

#image_max_array_size ⇒ Object

Returns the OpenCL::Device::image_max_array_size info

Returns:

  • size_t



180
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 180

get_info("Device", :size_t,  "image_max_array_size")

#image_max_buffer_size ⇒ Object

Returns the OpenCL::Device::image_max_buffer_size info

Returns:

  • size_t



179
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 179

get_info("Device", :size_t,  "image_max_buffer_size")

#linker_available ⇒ Object

Returns the OpenCL::Device::linker_available info

Returns:

  • cl_bool



181
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 181

get_info("Device", :cl_bool, "linker_available")

#parent_device ⇒ Object

Returns the parent Device if it exists



184
185
186
187
188
189
190
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 184

def parent_device
  ptr = MemoryPointer::new( Device )
  error = OpenCL.clGetDeviceInfo(self, PARENT_DEVICE, Device.size, ptr, nil)
  error_check(error)
  return nil if ptr.null?
  return Device::new(ptr.read_pointer)
end

#partition_affinity_domain ⇒ Object

Returns the OpenCL::Device::partition_affinity_domain info

Returns:

  • cl_device_affinity_domain



209
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 209

get_info("Device", :cl_device_affinity_domain, "partition_affinity_domain")

#partition_by_affinity_domain(affinity_domain = AFFINITY_DOMAIN_NEXT_PARTITIONABLE) ⇒ Object

Partitions the Device in serveral sub-devices by affinity domain

Attributes

  • affinity_domain - the :cl_device_partition_property specifying the target affinity domain

Returns

an Array of Device



280
281
282
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 280

def partition_by_affinity_domain( affinity_domain = AFFINITY_DOMAIN_NEXT_PARTITIONABLE )
  return OpenCL.create_sub_devices( self,  [ PARTITION_BY_AFFINITY_DOMAIN, affinity_domain ] )
end

#partition_by_counts(*compute_unit_count_list) ⇒ Object

Partitions the Device in serveral sub-devices each containing a specific number of compute units

Attributes

  • compute_unit_count_list - an Array of compute unit counts

Returns

an Array of Device



306
307
308
309
310
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 306

def partition_by_counts( *compute_unit_count_list )
  compute_unit_count_list = [1] if compute_unit_count_list == []
  compute_unit_count_list.flatten!
  return OpenCL.create_sub_devices( self,  [ PARTITION_BY_COUNTS] + compute_unit_count_list + [ PARTITION_BY_COUNTS_LIST_END ] )
end

#partition_by_names_intel(*compute_unit_name_list) ⇒ Object 



312
313
314
315
316
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 312

def partition_by_names_intel( *compute_unit_name_list )
  compute_unit_name_list = [0] if compute_unit_name_list == []
  compute_unit_name_list.flatten!
  return OpenCL.create_sub_devices( self,  [ Partition::BY_NAMES_INTEL ] + compute_unit_name_list + [ Partition::BY_NAMES_LIST_END_INTEL ] )
end

#partition_equally(compute_unit_number = 1) ⇒ Object

Partitions the Device in serveral sub-devices containing compute_unit_number compute units

Attributes

  • compute_unit_number - the number of compute units in each sub-device

Returns

an Array of Device



293
294
295
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 293

def partition_equally( compute_unit_number = 1 )
  return OpenCL.create_sub_devices( self,  [ PARTITION_EQUALLY, compute_unit_number ] )
end

#partition_max_sub_devices ⇒ Object

Returns the OpenCL::Device::partition_max_sub_devices info

Returns:

  • cl_uint



192
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 192

get_info("Device", :cl_uint, "partition_max_sub_devices")

#partition_properties ⇒ Object

Returns the list of partition types supported by the Device



197
198
199
200
201
202
203
204
205
206
207
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 197

def partition_properties
  ptr1 = MemoryPointer::new( :size_t, 1)
  error = OpenCL.clGetDeviceInfo(self, PARTITION_PROPERTIES, 0, nil, ptr1)
  error_check(error)
  ptr2 = MemoryPointer::new( ptr1.read_size_t )
  error = OpenCL.clGetDeviceInfo(self, PARTITION_PROPERTIES, ptr1.read_size_t, ptr2, nil)
  error_check(error)
  arr = ptr2.get_array_of_cl_device_partition_property(0, ptr1.read_size_t/ OpenCL.find_type(:cl_device_partition_property).size)
  arr.reject! { |e| e.null? }
  return arr.collect { |e| Partition::new(e.to_i) }
end

#partition_type ⇒ Object

Returns a list of :cl_device_partition_property used to create the Device



214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 214

def partition_type
  ptr1 = MemoryPointer::new( :size_t, 1)
  error = OpenCL.clGetDeviceInfo(self, PARTITION_TYPE, 0, nil, ptr1)
  error_check(error)
  ptr2 = MemoryPointer::new( ptr1.read_size_t )
  error = OpenCL.clGetDeviceInfo(self, PARTITION_TYPE, ptr1.read_size_t, ptr2, nil)
  error_check(error)
  arr = ptr2.get_array_of_cl_device_partition_property(0, ptr1.read_size_t/ OpenCL.find_type(:cl_device_partition_property).size)
  return [] if arr.length == 0
  ptype = arr.first.to_i
  arr_2 = []
  arr_2.push( Partition::new(ptype) )
  return arr_2 if arr.length == 1
  case ptype
  when Partition::BY_NAMES_EXT
    i = 1
    while arr[i].to_i - (0x1 << Pointer.size * 8) != Partition::BY_NAMES_LIST_END_EXT do
      arr_2.push( arr[i].to_i )
      i += 1
      return arr_2 if arr.length <= i
    end
    arr_2.push( Partition::new(Partition::BY_NAMES_LIST_END_EXT) )
    arr_2.push( 0 )
  when Partition::EQUALLY
    arr_2.push(arr[1].to_i)
    arr_2.push( 0 )
  when Partition::BY_COUNTS
    i = 1
    while arr[i].to_i != Partition::BY_COUNTS_LIST_END do
      arr_2.push( arr[i].to_i )
      i += 1
      return arr_2 if arr.length <= i
    end
    arr_2.push( Partition::new(Partition::BY_COUNTS_LIST_END) )
    arr_2.push( 0 )
  end
  return arr_2
end

#preferred_interop_user_sync ⇒ Object

Returns the OpenCL::Device::preferred_interop_user_sync info

Returns:

  • cl_bool



254
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 254

get_info("Device", :cl_bool, "preferred_interop_user_sync")

#printf_buffer_size ⇒ Object

Returns the OpenCL::Device::printf_buffer_size info

Returns:

  • size_t



253
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 253

get_info("Device", :size_t,  "printf_buffer_size")

#reference_count ⇒ Object

Returns the OpenCL::Device::reference_count info

Returns:

  • cl_uint



255
 
# File 'lib/opencl_ruby_ffi/Device.rb', line 255

get_info("Device", :cl_uint, "reference_count")