opencl_ruby_ffi 1.3.6 → 1.3.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4325bde909438bcb5c293f84f9f3f7da0932abf023bc87df395110af66fde34
-  data.tar.gz: 745fc7ce91505ae771d56fbf386a0d650dbd5866c0cf2bbde4b799af29f5d655
+  metadata.gz: 065ec7c422916ba7d169142533db9bd995454f4ba4f1c15140a9520678a2bfd6
+  data.tar.gz: bbc4f7adf1314fc7d52ac0d17f055395f49f0b36cee51a93ccd13ad7463ad99a
 SHA512:
-  metadata.gz: b88bd68ba1ab4a335e6342eb62a38b07709669a1c2ac32b572d5f46e13138002a33c7efe790c0f1342a9348b30711a2f0b165418abf404fc3bf4f05f9819cc67
-  data.tar.gz: 7dedd2f91608263c61c13a997a9949b240dd24c34fa2fd130466007c3ad571d86f81e00c98b64ec5b0b384c11e7ab22d51a444c255deee83b9114b7752def527
+  metadata.gz: cf5f687a27e5366205e978a0040da1f973e543953f286221c8bf0af9a0b2089d42f826039965cdf59bd9c1c7f64dca51b2bc50663818093fe667a5435dc429bf
+  data.tar.gz: 249cdaa1aba3ede6812b759c41fe21e468b40c15621f04e759829507dea1597d9fc2e31b85d8c0ef54cc65c0828da683ff0d6ad88414b14b22b87085c477b0f2

data/lib/opencl_ruby_ffi.rb

@@ -2,6 +2,7 @@ require "opencl_ruby_ffi/opencl_types.rb"
 require "opencl_ruby_ffi/opencl_ruby_ffi_base_gen.rb"
 require "opencl_ruby_ffi/opencl_arithmetic_gen.rb"
 require "opencl_ruby_ffi/opencl_ruby_ffi_base.rb"
+require "opencl_ruby_ffi/opencl_ruby_ffi_library.rb"
 require "opencl_ruby_ffi/Context.rb"
 require "opencl_ruby_ffi/Platform.rb"
 require "opencl_ruby_ffi/Device.rb"

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
@@ -1070,6 +1070,11 @@ module OpenCL
       return "#<#{self.class.name}: -> #{device.inspect}#{ 0 != p.to_i ? " (#{p})" : ""}>"
     end
 
+    # Returns the Platform associated with the CommandQueue
+    def platform
+      @_platform ||= self.context.platform
+    end
+
     # Returns the Context associated to the CommandQueue
     def context
       ptr = MemoryPointer::new( Context )
@@ -1654,11 +1659,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
@@ -1666,8 +1671,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
@@ -1696,31 +1701,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
@@ -1728,8 +1734,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
@@ -1783,10 +1789,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,25 @@ module OpenCL
 
     # Returns the number of devices associated to the Context
     def 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 ||= begin
+        ptr = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetContextInfo(self, DEVICES, 0, nil, ptr)
+        error_check(error)
+        ptr.read_size_t / Platform.size
+      end
     end
 
     # Returns an Array of Device associated to the Context
     def 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|
-        Device::new(device_ptr)
-      }
+      @_devices ||= begin
+        n = self.num_devices
+        ptr2 = MemoryPointer::new( Device, n )
+        error = OpenCL.clGetContextInfo(self, DEVICES, Device.size*n, ptr2, nil)
+        error_check(error)
+        ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
+          Device::new(device_ptr)
+        }
+      end
     end
 
     ##
@@ -118,7 +168,7 @@ module OpenCL
 
     # Returns the platform associated to the Context
     def platform
-      self.devices.first.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 +501,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,18 @@ 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
-      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 ||= begin
+        ptr = MemoryPointer::new( OpenCL::Platform )
+        error = OpenCL.clGetDeviceInfo(self, PLATFORM, OpenCL::Platform.size, ptr, nil)
+        error_check(error)
+        OpenCL::Platform::new(ptr.read_pointer)
+      end
     end
 
     get_info("Device", :cl_uint, "preferred_vector_width_char")
@@ -119,14 +121,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 +142,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")
@@ -156,8 +159,6 @@ module OpenCL
         n = ver.scan(/OpenCL C (\d+\.\d+)/)
         return n.first.first.to_f
       end
-
-      get_info("Device", :cl_uint, "preferred_vector_width_half")
  
     end
 
@@ -364,10 +365,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