opencl_ruby_ffi 1.3.3 → 1.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2aaf99112a7a7223edf3461b3e7c813d3c0c44b0
-  data.tar.gz: 7c5bb20e06c5152dcfacd31f1506f2d3205b0f21
+SHA256:
+  metadata.gz: 409ed20eac2dc9aa0d410563053699e18528cd62471903fd862ee2f31bb60a81
+  data.tar.gz: 670b281a4ab283be7a8c429474008e9e280987e8d81bc5222a853c32a10a569b
 SHA512:
-  metadata.gz: 63aa2044a7c9322484e92e6d72c7f41df687c8c8204a20ac26539dd017aff5c4dedbeb86edd170645f9cfdc0ec712de5461b0bbd125fbceb89cd3db2aacf02c8
-  data.tar.gz: 88633e9e8fd7d3c5d54a4d422cc2bcd3999631863cdca78054ceba5454a45246e88a7ad09cd71c67e560e0f08475323b60053baf886463844a96cdf1129ef246
+  metadata.gz: 9301ea0a86feed2d72684a63366ad1b6862cd8238497854b768044814940c3f7ec39a7badfa11d56cead96d0c01fddb64092b56d1399d5a8395ce6d9305754f9
+  data.tar.gz: 8fa725c1e61931b3d9cdff0cf5d557055398ecf058d56289a72bca1ee3d2e54f80d279266e2185177ac59f9386f32422054e6437e19f23f452a65c060c45fe0c

data/lib/opencl_ruby_ffi/Buffer.rb

@@ -13,11 +13,17 @@ module OpenCL
   # 
   # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
   # * +:host_ptr+ - if provided, the Pointer (or convertible to Pointer using to_ptr) to the memory area to use
+  # * +:properties+ - if provided, an array of :cl_mem_properties (OpenCL 3.0)
   def self.create_buffer( context, size, options = {} )
     flags = get_flags( options )
     host_ptr = options[:host_ptr]
     error = MemoryPointer::new( :cl_int )
-    buff = clCreateBuffer(context, flags, size, host_ptr, error)
+    if context.platform.version_number < 3.0 then
+      buff = clCreateBuffer(context, flags, size, host_ptr, error)
+    else
+      properties = get_mem_properties( options )
+      buff = clCreateBufferWithProperties(context, properties, flags, size, host_ptr, error)
+    end
     error_check(error.read_cl_int)
     return Buffer::new( buff, false )
   end

data/lib/opencl_ruby_ffi/CommandQueue.rb

@@ -566,7 +566,7 @@ module OpenCL
     objs = nil
     if num_objs > 0 then
       objs = MemoryPointer::new(  Mem, num_objs )
-      [mem_objects].flatten.each_with_index { |o, i|
+      [mem_objects].flatten.each_with_index { |e, i|
         objs[i].write_pointer(e)
       }
     end
@@ -600,7 +600,7 @@ module OpenCL
     objs = nil
     if num_objs > 0 then
       objs = MemoryPointer::new( Mem, num_objs )
-      [mem_objects].flatten.each_with_index { |o, i|
+      [mem_objects].flatten.each_with_index { |e, i|
         objs[i].write_pointer(e)
       }
     end
@@ -639,7 +639,8 @@ module OpenCL
     offset = options[:offset] if options[:offset]
     pattern_size = pattern.size
     pattern_size = options[:pattern_size] if options[:pattern_size]
-    size = (buffer.size - offset) % pattern_size
+    size = (buffer.size - offset)
+    size -= size % pattern_size
     size = options[:size] if options[:size]
     num_events, events = get_event_wait_list( options )
     event = MemoryPointer::new( Event )
@@ -1069,6 +1070,12 @@ module OpenCL
       return "#<#{self.class.name}: -> #{device.inspect}#{ 0 != p.to_i ? " (#{p})" : ""}>"
     end
 
+    # Returns the Platform associated with the CommandQueue
+    def platform
+      return @_platform if @_platform
+      @_platform = self.context.platform
+    end
+
     # Returns the Context associated to the CommandQueue
     def context
       ptr = MemoryPointer::new( Context )
@@ -1653,11 +1660,11 @@ module OpenCL
       # 
       # * +dst_ptr+ - the Pointer (or convertible to Pointer using to_ptr) or SVMPointer to be written to
       # * +src_ptr+ - the Pointer (or convertible to Pointer using to_ptr) or SVMPointer to be read from
-      # * +size+ - the size of data to copy
       # * +options+ - a hash containing named options
       #
       # ==== Options
       #
+      # * +:size+ - the size of data to copy
       # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
       # * +:blocking_copy+ - if provided indicates if the command blocks until the copy finishes
       # * +:blocking+ - if provided indicates if the command blocks until the copy finishes
@@ -1665,8 +1672,8 @@ module OpenCL
       # ==== Returns
       #
       # the Event associated with the command
-      def enqueue_svm_memcpy( dst_ptr, src_ptr, size, options = {})
-        return OpenCL.enqueue_svm_memcpy(self, dst_ptr, src_ptr, size, options)
+      def enqueue_svm_memcpy( dst_ptr, src_ptr, options = {})
+        return OpenCL.enqueue_svm_memcpy(self, dst_ptr, src_ptr, options)
       end
 
       # Enqueues a command that frees SVMPointers (or Pointers using a callback) using the CommandQueue
@@ -1695,31 +1702,32 @@ module OpenCL
       #
       # * +svm_ptr+ - the SVMPointer to the area to fill
       # * +pattern+ - the Pointer (or convertible to Pointer using to_ptr) to the memory area where the pattern is stored
-      # * +size+ - the size of the area to fill
       #
       # ==== Options
       #
+      # * +:size+ - the size of the area to fill
       # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
       # * +:pattern_size+ - if provided indicates the size of the pattern, else the maximum pattern data is used
       #
       # ==== Returns
       #
       # the Event associated with the command
-      def enqueue_svm_memfill( svm_ptr, pattern, size, options = {})
-        return OpenCL.enqueue_svm_memfill(self, svm_ptr, pattern, size, options)
+      def enqueue_svm_memfill( svm_ptr, pattern, options = {})
+        return OpenCL.enqueue_svm_memfill(self, svm_ptr, pattern, options)
       end
+      alias enqueue_svm_mem_fill enqueue_svm_memfill
 
       # Enqueues a command to map an Image into host memory using the CommandQueue
       #
       # ==== Attributes
       # 
       # * +svm_ptr+ - the SVMPointer to the area to map
-      # * +size+ - the size of the region to map
       # * +map_flags+ - a single or an Array of :cl_map_flags flags
       # * +options+ - a hash containing named options
       #
       # ==== Options
       #
+      # * +:size+ - the size of the region to map
       # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
       # * +:blocking_map+ - if provided indicates if the command blocks until the region is mapped
       # * +:blocking+ - if provided indicates if the command blocks until the region is mapped
@@ -1727,8 +1735,8 @@ module OpenCL
       # ==== Returns
       #
       # the Event associated with the command
-      def enqueue_svm_map( svm_ptr, size, map_flags, options = {} )
-        return OpenCL.enqueue_svm_map( self, svm_ptr, size, map_flags, options )
+      def enqueue_svm_map( svm_ptr, map_flags, options = {} )
+        return OpenCL.enqueue_svm_map( self, svm_ptr, map_flags, options )
       end
     
       # Enqueues a command to unmap a previously mapped SVM memory area using the CommandQueue
@@ -1782,10 +1790,17 @@ module OpenCL
 
     end
 
+    module OpenCL30
+      extend InnerGenerator
+
+      get_info_array("CommandQueue", :cl_queue_properties, "properties_array")
+    end
+
     register_extension( :v11, OpenCL11, "device.platform.version_number >= 1.1" )
     register_extension( :v12, OpenCL12, "device.platform.version_number >= 1.2" )
     register_extension( :v20, OpenCL20, "device.platform.version_number >= 2.0" )
     register_extension( :v21, OpenCL21, "device.platform.version_number >= 2.1" )
+    register_extension( :v30, OpenCL30, "device.platform.version_number >= 3.0" )
 
   end
 

data/lib/opencl_ruby_ffi/Context.rb

@@ -14,7 +14,9 @@ module OpenCL
   # * +:properties+ - a list of :cl_context_properties
   # * +:user_data+ - an Pointer or an object that can be converted into one using to_ptr. The pointer is passed to the callback.
   def self.create_context(devices, options = {}, &block)
-    @@callbacks.push( block ) if block
+    if block
+      @@callbacks[block] = options[:user_data]
+    end
     devs = [devices].flatten
     pointer = MemoryPointer::new( Device, devs.size)
     pointer.write_array_of_pointer(devs)
@@ -23,7 +25,16 @@ module OpenCL
     error = MemoryPointer::new( :cl_int )
     ptr = clCreateContext(properties, devs.size, pointer, block, user_data, error)
     error_check(error.read_cl_int)
-    return Context::new(ptr, false)
+    context = Context::new(ptr, false)
+    if block && context.platform.version_number >= 3.0
+      callback_destructor_callback = lambda { |c, u|
+        @@callbacks.delete(block)
+        @@callbacks.delete(callback_destructor_callback)
+      }
+      @@callbacks[callback_destructor_callback] = nil
+      context.set_destructor_callback(&callback_destructor_callback)
+    end
+    return context
   end
 
   # Creates an Context using devices of the selected type
@@ -39,13 +50,24 @@ module OpenCL
   # * +:properties+ - a list of :cl_context_properties
   # * +:user_data+ - an Pointer or an object that can be converted into one using to_ptr. The pointer is passed to the callback.
   def self.create_context_from_type(type, options = {}, &block)
-    @@callbacks.push( block ) if block
+    if block
+      @@callbacks[block] = options[:user_data]
+    end
     properties = get_context_properties( options )
     user_data = options[:user_data]
     error = MemoryPointer::new( :cl_int )
     ptr = clCreateContextFromType(properties, type, block, user_data, error)
     error_check(error.read_cl_int)
-    return Context::new(ptr, false)
+    context = Context::new(ptr, false)
+    if block && context.platform.version_number >= 3.0
+      callback_destructor_callback = lambda { |c, u|
+        @@callbacks.delete(block)
+        @@callbacks.delete(callback_destructor_callback)
+      }
+      @@callbacks[callback_destructor_callback] = nil
+      context.set_destructor_callback(&callback_destructor_callback)
+    end
+    return context
   end
 
   def self.set_default_device_command_queue( context, device, command_queue )
@@ -55,6 +77,32 @@ module OpenCL
     return context
   end
 
+  # Attaches a callback to context that will be called on context destruction
+  #
+  # ==== Attributes
+  #
+  # * +context+ - the Program to attach the callback to
+  # * +options+ - a hash containing named options
+  # * +block+ - if provided, a callback invoked when program is released. Signature of the callback is { |Pointer to the context, Pointer to user_data| ... }
+  #
+  # ==== Options
+  #
+  # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
+  def self.set_context_destructor_callback( context, options = {}, &block )
+    if block
+      wrapper_block = lambda { |p, u|
+        block.call(p, u)
+        @@callbacks.delete(wrapper_block)
+      }
+      @@callbacks[wrapper_block] = options[:user_data]
+    else
+      wrapper_block = nil
+    end
+    error = clSetContextDestructorCallback( context, wrapper_block, options[:user_data] )
+    error_check(error)
+    return context
+  end
+
   #Maps the cl_context object of OpenCL
   class Context
     include InnerInterface
@@ -68,23 +116,26 @@ module OpenCL
 
     # Returns the number of devices associated to the Context
     def num_devices
+      return @_num_devices if @_num_devices
       d_n = 0
       ptr = MemoryPointer::new( :size_t )
       error = OpenCL.clGetContextInfo(self, DEVICES, 0, nil, ptr)
       error_check(error)
       d_n = ptr.read_size_t / Platform.size
-      return d_n
+      @_num_devices = d_n
     end
 
     # Returns an Array of Device associated to the Context
     def devices
+      return @_devices if @_devices
       n = self.num_devices
       ptr2 = MemoryPointer::new( Device, n )
       error = OpenCL.clGetContextInfo(self, DEVICES, Device.size*n, ptr2, nil)
       error_check(error)
-      return ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
+      @_devices = ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
         Device::new(device_ptr)
       }
+      return @_devices
     end
 
     ##
@@ -118,7 +169,8 @@ module OpenCL
 
     # Returns the platform associated to the Context
     def platform
-      self.devices.first.platform
+      return @_platform if @_platform
+      @_platform = self.devices.first.platform
     end
 
     # Returns an Array of ImageFormat that are supported for a given image type in the Context
@@ -451,16 +503,36 @@ module OpenCL
         return OpenCL.create_program_with_il(self, il)
       end
 
+      # 
       def set_default_device_command_queue( device, command_queue )
         return OpenCL.set_default_device_command_queue( self, device, command_queue )
       end
 
     end
 
+    module OpenCL30
+      
+      # Attaches a callback to context that will be called on context destruction
+      #
+      # ==== Attributes
+      #
+      # * +options+ - a hash containing named options
+      # * +block+ - if provided, a callback invoked when program is released. Signature of the callback is { |Pointer to the context, Pointer to user_data| ... }
+      #
+      # ==== Options
+      #
+      # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
+      def set_destructor_callback( options = {}, &block )
+        OpenCL.set_context_destructor_callback( self, option, &block )
+        return self
+      end
+    end
+
     register_extension( :v11, OpenCL11, "platform.version_number >= 1.1" )
     register_extension( :v12, OpenCL12, "platform.version_number >= 1.2" )
     register_extension( :v20, OpenCL20, "platform.version_number >= 2.0" )
     register_extension( :v21, OpenCL21, "platform.version_number >= 2.1" )
+    register_extension( :v30, OpenCL30, "platform.version_number >= 3.0" )
 
   end
 

data/lib/opencl_ruby_ffi/Device.rb

@@ -14,7 +14,7 @@ module OpenCL
   def self.create_sub_devices( in_device, properties )
     error_check(INVALID_OPERATION) if in_device.platform.version_number < 1.2
     props = MemoryPointer::new( :cl_device_partition_property, properties.length + 1 )
-    properties.each_with_index { |e,i|
+    properties.each_with_index { |e, i|
       props[i].write_cl_device_partition_property(e)
     }
     props[properties.length].write_cl_device_partition_property(0)
@@ -56,7 +56,7 @@ module OpenCL
       return "#<#{self.class.name}: #{name} (#{pointer.to_i})>"
     end
 
-    get_info("Device", :cl_uint, "address_bits")
+    get_info("Device", :cl_uint, "address_bits", true)
     get_info("Device", :cl_bool, "available")
     get_info("Device", :cl_bool, "compiler_available")
     get_info("Device", :cl_bool, "endian_little")
@@ -101,16 +101,17 @@ module OpenCL
     get_info("Device", :cl_uint, "max_write_image_args")
     get_info("Device", :cl_uint, "mem_base_addr_align")
     get_info("Device", :cl_uint, "min_data_type_align_size")
-    get_info("Device", :string,  "name")
+    get_info("Device", :string,  "name", true)
 
     alias to_s name
 
     # Returns the Platform the Device belongs to
     def platform
+      return @_platform if @_platform
       ptr = MemoryPointer::new( OpenCL::Platform )
       error = OpenCL.clGetDeviceInfo(self, PLATFORM, OpenCL::Platform.size, ptr, nil)
       error_check(error)
-      return OpenCL::Platform::new(ptr.read_pointer)
+      @_platform = OpenCL::Platform::new(ptr.read_pointer)
     end
 
     get_info("Device", :cl_uint, "preferred_vector_width_char")
@@ -119,14 +120,14 @@ module OpenCL
     get_info("Device", :cl_uint, "preferred_vector_width_long")
     get_info("Device", :cl_uint, "preferred_vector_width_float")
     get_info("Device", :cl_uint, "preferred_vector_width_double")
-    get_info("Device", :string,  "profile")
+    get_info("Device", :string,  "profile", true)
     get_info("Device", :size_t,  "profiling_timer_resolution")
     get_info("Device", :cl_command_queue_properties, "queue_properties")
     get_info("Device", :cl_device_fp_config,         "single_fp_config")
-    get_info("Device", :cl_device_type, "type")
-    get_info("Device", :string,         "vendor")
-    get_info("Device", :cl_uint,        "vendor_id")
-    get_info("Device", :string,         "version")
+    get_info("Device", :cl_device_type, "type", true)
+    get_info("Device", :string,         "vendor", true)
+    get_info("Device", :cl_uint,        "vendor_id", true)
+    get_info("Device", :string,         "version", true)
 
     # returs a floating point number corresponding to the OpenCL version of the Device
     def version_number
@@ -140,6 +141,7 @@ module OpenCL
     module OpenCL11
       extend InnerGenerator
 
+      get_info("Device", :cl_uint, "preferred_vector_width_half")
       get_info("Device", :cl_bool, "host_unified_memory")
       get_info("Device", :cl_uint, "native_vector_width_char")
       get_info("Device", :cl_uint, "native_vector_width_short")
@@ -364,10 +366,90 @@ module OpenCL
 
     end
 
-    register_extension( :v11,  OpenCL11, "platform.version_number >= 1.1" )
-    register_extension( :v12,  OpenCL12, "platform.version_number >= 1.2" )
-    register_extension( :v20,  OpenCL20, "platform.version_number >= 2.0" )
-    register_extension( :v21,  OpenCL21, "platform.version_number >= 2.1" )
+    module OpenCL30
+      extend InnerGenerator
+      get_info("Device", :cl_device_atomic_capabilities, "atomic_memory_capabilities")
+      get_info("Device", :cl_device_atomic_capabilities, "atomic_fence_capabilities")
+      get_info("Device", :cl_bool, "non_uniform_work_group_support")
+      get_info("Device", :size_t, "preferred_work_group_size_multiple")
+      get_info("Device", :cl_bool, "work_group_collective_functions_support")
+      get_info("Device", :cl_bool, "generic_address_space_support")
+      get_info("Device", :cl_bool, "device_enqueue_support")
+      get_info("Device", :cl_bool, "pipe_support")
+
+      def numeric_version
+        ptr = MemoryPointer::new( :cl_version )
+        error = OpenCL.clGetDeviceInfo( self, NUMERIC_VERSION, 4, ptr, nil)
+        error_check(error)
+        return Version::from_int(ptr.read_cl_version)
+      end
+
+      def extensions_with_version
+        sz = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetDeviceInfo( self, EXTENSIONS_WITH_VERSION, 0, nil, sz)
+        error_check(error)
+        sz = sz.read_size_t
+        ptr = MemoryPointer::new( sz )
+        error = OpenCL.clGetDeviceInfo( self, EXTENSIONS_WITH_VERSION, sz, ptr, nil)
+        error_check(error)
+        nvsz = NameVersion.size
+        return (sz/nvsz).times.collect { |i| NameVersion::new(ptr + i*nvsz) }
+      end
+
+      def ils_with_version
+        sz = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetDeviceInfo( self, ILS_WITH_VERSION, 0, nil, sz)
+        error_check(error)
+        sz = sz.read_size_t
+        ptr = MemoryPointer::new( sz )
+        error = OpenCL.clGetDeviceInfo( self, ILS_WITH_VERSION, sz, ptr, nil)
+        error_check(error)
+        nvsz = NameVersion.size
+        return (sz/nvsz).times.collect { |i| NameVersion::new(ptr + i*nvsz) }
+      end
+
+      def built_in_kernels_with_version
+        sz = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS_WITH_VERSION, 0, nil, sz)
+        error_check(error)
+        sz = sz.read_size_t
+        ptr = MemoryPointer::new( sz )
+        error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS_WITH_VERSION, sz, ptr, nil)
+        error_check(error)
+        nvsz = NameVersion.size
+        return (sz/nvsz).times.collect { |i| NameVersion::new(ptr + i*nvsz) }
+      end
+
+      def opencl_c_all_versions
+        sz = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetDeviceInfo( self, OPENCL_C_ALL_VERSIONS, 0, nil, sz)
+        error_check(error)
+        sz = sz.read_size_t
+        ptr = MemoryPointer::new( sz )
+        error = OpenCL.clGetDeviceInfo( self, OPENCL_C_ALL_VERSIONS, sz, ptr, nil)
+        error_check(error)
+        nvsz = NameVersion.size
+        return (sz/nvsz).times.collect { |i| NameVersion::new(ptr + i*nvsz) }
+      end
+
+      def opencl_c_features
+        sz = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetDeviceInfo( self, OPENCL_C_FEATURES, 0, nil, sz)
+        error_check(error)
+        sz = sz.read_size_t
+        ptr = MemoryPointer::new( sz )
+        error = OpenCL.clGetDeviceInfo( self, OPENCL_C_FEATURES, sz, ptr, nil)
+        error_check(error)
+        nvsz = NameVersion.size
+        return (sz/nvsz).times.collect { |i| NameVersion::new(ptr + i*nvsz) }
+      end
+    end
+
+    register_extension( :v11, OpenCL11, "platform.version_number >= 1.1" )
+    register_extension( :v12, OpenCL12, "platform.version_number >= 1.2" )
+    register_extension( :v20, OpenCL20, "platform.version_number >= 2.0" )
+    register_extension( :v21, OpenCL21, "platform.version_number >= 2.1" )
+    register_extension( :v30, OpenCL30, "platform.version_number >= 3.0" )
 
   end