opencl_ruby_ffi 1.3.4 → 1.3.9

data/lib/opencl_ruby_ffi/intel/unofficial.rb

@@ -0,0 +1,95 @@
+if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+  using OpenCLRefinements
+end
+
+module OpenCL
+
+  # Unofficial kernel profiling extension
+  CONTEXT_KERNEL_PROFILING_MODES_COUNT_INTEL = 0x407A
+  CONTEXT_KERNEL_PROFILING_MODE_INFO_INTEL   = 0x407B
+  KERNEL_IL_SYMBOLS_INTEL                    = 0x407C
+  KERNEL_BINARY_PROGRAM_INTEL                = 0x407D
+  # Unofficial VTune Debug Info extension
+  PROGRAM_DEBUG_INFO_INTEL                   = 0x4100
+  PROGRAM_DEBUG_INFO_SIZES_INTEL             = 0x4101
+  KERNEL_BINARIES_INTEL                      = 0x4102
+  KERNEL_BINARY_SIZES_INTEL                  = 0x4103
+
+  class Kernel
+    IL_SYMBOLS_INTEL                    = 0x407C
+    BINARY_PROGRAM_INTEL                = 0x407D
+    BINARIES_INTEL                      = 0x4102
+    BINARY_SIZES_INTEL                  = 0x4103
+ 
+    def binary_program_intel(device = program.devices.first)
+      sz = MemoryPointer::new( :size_t )
+      begin
+        error = OpenCL.clGetKernelWorkGroupInfo(self, device, BINARY_PROGRAM_INTEL, 0, nil, sz)
+        error_check(error)
+        sz = sz.read_size_t
+        bin = MemoryPointer::new(sz)
+        error = OpenCL.clGetKernelWorkGroupInfo(self, device, BINARY_PROGRAM_INTEL, sz, bin, nil)
+        error_check(error)
+        return bin.read_bytes(sz)
+      rescue
+        error = OpenCL.clGetKernelInfo(self, BINARY_PROGRAM_INTEL, 0, nil, sz)
+        error_check(error)
+        sz = sz.read_size_t
+        bin = MemoryPointer::new(sz)
+        error = OpenCL.clGetKernelInfo(self, BINARY_PROGRAM_INTEL, sz, bin, nil)
+        error_check(error)
+        return bin.read_bytes(sz)
+      end
+    end
+
+    get_info_array("Kernel", :size_t, "binary_sizes_intel")
+
+    def binaries_intel
+      sizes = self.binary_sizes_intel
+      bin_array = MemoryPointer::new( :pointer, sizes.length )
+      total_size = 0
+      pointers = []
+      sizes.each_with_index { |s, i|
+        total_size += s
+        pointers[i] = MemoryPointer::new(s)
+        bin_array[i].write_pointer(pointers[i])
+      }
+      error = OpenCL.clGetKernelInfo(self, BINARIES_INTEL, total_size, bin_array, nil)
+      error_check(error)
+      bins = []
+      devs = self.program.devices
+      sizes.each_with_index { |s, i|
+        bins.push [devs[i], pointers[i].read_bytes(s)]
+      }
+      return bins
+    end
+
+  end
+
+  class Program
+    DEBUG_INFO_INTEL                   = 0x4100
+    DEBUG_INFO_SIZES_INTEL             = 0x4101
+
+    get_info_array("Program", :size_t, "debug_info_sizes_intel")
+
+    def debug_info_intel
+      sizes = self.debug_info_sizes_intel
+      bin_array = MemoryPointer::new( :pointer, sizes.length )
+      total_size = 0
+      sizes.each_with_index { |s, i|
+        total_size += s
+        pointers[i] = MemoryPointer::new(s)
+        bin_array[i].write_pointer(pointers[i])
+      }
+      error = OpenCL.clGetProgramInfo(self, DEBUG_INFO_INTEL, total_size, bin_array, nil)
+      error_check(error)
+      bins = []
+      devs = self.devices
+      sizes.each_with_index { |s, i|
+        bins.push [devs[i], pointers[i].read_bytes(s)]
+      }
+      return bins
+    end
+  end
+
+end

data/lib/opencl_ruby_ffi/khr/device_uuid.rb

@@ -0,0 +1,119 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  UUID_SIZE_KHR = 16
+  LUID_SIZE_KHR = 8
+
+  DEVICE_UUID_KHR = 0x106A
+  DRIVER_UUID_KHR = 0x106B
+  DEVICE_LUID_VALID_KHR = 0x106C
+  DEVICE_LUID_KHR = 0x106D
+  DEVICE_NODE_MASK_KHR = 0x106E
+
+  class UUID < Struct
+    layout :id, [ OpenCL.find_type(:cl_uchar), UUID_SIZE_KHR ]
+    def to_s
+      a = self[:id].to_a
+      s = ""
+      s << "%02x" % a[15]
+      s << "%02x" % a[14]
+      s << "%02x" % a[13]
+      s << "%02x" % a[12]
+      s << "-"
+      s << "%02x" % a[11]
+      s << "%02x" % a[10]
+      s << "-"
+      s << "%02x" % a[9]
+      s << "%02x" % a[8]
+      s << "-"
+      s << "%02x" % a[7]
+      s << "%02x" % a[6]
+      s << "-"
+      s << "%02x" % a[5]
+      s << "%02x" % a[4]
+      s << "%02x" % a[3]
+      s << "%02x" % a[2]
+      s << "%02x" % a[1]
+      s << "%02x" % a[0]
+    end
+
+    def self.from_string(uuid)
+      new.from_string(uuid)
+    end
+
+    def from_string(uuid)
+      m = uuid.match(/(\h\h)(\h\h)(\h\h)(\h\h)-(\h\h)(\h\h)-(\h\h)(\h\h)-(\h\h)(\h\h)-(\h\h)(\h\h)(\h\h)(\h\h)(\h\h)(\h\h)/)
+      raise "invalid format" unless m
+      UUID_SIZE_KHR.times { |i|
+        self[:id][UUID_SIZE_KHR-1-i] = m[i+1].to_i(16)
+      }
+      self
+    end
+  end
+
+  class LUID < Struct
+    layout :id, [ OpenCL.find_type(:cl_uchar), LUID_SIZE_KHR ]
+    def to_s
+      a = self[:id].to_a
+      s = ""
+      s << "%02x" % a[7]
+      s << "%02x" % a[6]
+      s << "%02x" % a[5]
+      s << "%02x" % a[4]
+      s << "%02x" % a[3]
+      s << "%02x" % a[2]
+      s << "%02x" % a[1]
+      s << "%02x" % a[0]
+    end
+
+    def self.from_string(uuid)
+      new.from_string(uuid)
+    end
+
+    def from_string(uuid)
+      m = uuid.match(/(\h\h)(\h\h)(\h\h)(\h\h)(\h\h)(\h\h)(\h\h)(\h\h)/)
+      raise "invalid format" unless m
+      LUID_SIZE_KHR.times { |i|
+        self[:id][LUID_SIZE_KHR-1-i] = m[i+1].to_i(16)
+      }
+      self
+    end
+  end
+
+  class Device
+    UUID_KHR = 0x106A
+    LUID_VALID_KHR = 0x106C
+    LUID_KHR = 0x106D
+    NODE_MASK_KHR = 0x106E
+
+    module KHRDeviceUUID
+      extend InnerGenerator
+      get_info("Device", :cl_bool, "luid_valid_khr")
+      get_info("Device", :cl_uint, "node_mask_khr")
+
+      def uuid_khr
+        id = UUID.new
+        error = OpenCL.clGetDeviceInfo( self, UUID_KHR, UUID_SIZE_KHR, id, nil)
+        error_check(error)
+        return id
+      end
+
+      def driver_uuid_khr
+        id = UUID.new
+        error = OpenCL.clGetDeviceInfo( self, DRIVER_UUID_KHR, UUID_SIZE_KHR, id, nil)
+        error_check(error)
+        return id
+      end
+
+      def luid_khr
+        id = LUID.new
+        error = OpenCL.clGetDeviceInfo( self, LUID_KHR, LUID_SIZE_KHR, id, nil)
+        error_check(error)
+        return id
+      end
+    end
+    register_extension( :cl_khr_device_uuid, KHRDeviceUUID, "extensions.include?(\"cl_khr_device_uuid\")" )
+  end
+
+end

data/lib/opencl_ruby_ffi/opencl_ruby_ffi_base.rb

@@ -35,7 +35,7 @@ module OpenCL
   class Union < FFI::Union
   end
 
-  @@callbacks = []
+  @@callbacks = {}
 
   # Maps the :cl_image_fomat type of OpenCL
   class ImageFormat < Struct
@@ -47,13 +47,13 @@ module OpenCL
     end
 
     # Creates a new ImageFormat from an image channel order and data type
-    def initialize( image_channel_order, image_channel_data_type = nil )
-      if image_channel_order.is_a?(FFI::Pointer) and image_channel_data_type.nil? then
+    def initialize( image_channel_order = nil, image_channel_data_type = nil )
+      if image_channel_order.is_a?(FFI::Pointer) then
         super(image_channel_order)
       else
         super()
-        self[:image_channel_order] = image_channel_order
-        self[:image_channel_data_type] = image_channel_data_type
+        self[:image_channel_order] = image_channel_order if image_channel_order
+        self[:image_channel_data_type] = image_channel_data_type if image_channel_data_type
       end
     end
 
@@ -98,18 +98,22 @@ module OpenCL
            :buffer,               Mem.ptr
 
      # Creates anew ImageDesc using the values provided by the user
-     def initialize( image_type, image_width, image_height, image_depth, image_array_size, image_row_pitch, image_slice_pitch, num_mip_levels, num_samples, buffer )
-       super()
-       self[:image_type] = image_type
-       self[:image_width] = image_width
-       self[:image_height] = image_height
-       self[:image_depth] = image_depth
-       self[:image_array_size] = image_array_size
-       self[:image_row_pitch] = image_row_pitch
-       self[:image_slice_pitch] = image_slice_pitch
-       self[:num_mip_levels] = num_mip_levels
-       self[:num_samples] = num_samples
-       self[:buffer] = buffer
+     def initialize( image_type = nil, image_width = nil, image_height = nil, image_depth = nil, image_array_size = nil, image_row_pitch = nil, image_slice_pitch = nil, num_mip_levels = nil, num_samples = nil, buffer = nil )
+       if (image_type.is_a?(FFI::Pointer))
+         super(image_type)
+       else
+         super()
+         self[:image_type] = image_type if image_type
+         self[:image_width] = image_width if image_width
+         self[:image_height] = image_height if image_height
+         self[:image_depth] = image_depth if image_depth
+         self[:image_array_size] = image_array_size if image_array_size
+         self[:image_row_pitch] = image_row_pitch if image_row_pitch
+         self[:image_slice_pitch] = image_slice_pitch if image_slice_pitch
+         self[:num_mip_levels] = num_mip_levels if num_mip_levels
+         self[:num_samples] = num_samples if num_samples
+         self[:buffer] = buffer if buffer
+       end
      end
   end
 
@@ -119,10 +123,84 @@ module OpenCL
            :size,   :size_t
 
     # Creates a new BufferRegion using the value provided by the user
-    def initialize( origin, sz )
-      super()
-      self[:origin] = origin
-      self[:size]   = sz
+    def initialize( origin = nil, sz = nil )
+      if (origin.is_a?(FFI::Pointer))
+        super(origin)
+      else
+        super()
+        self[:origin] = origin if origin
+        self[:size]   = sz if sz
+      end
+    end
+  end
+
+  class Version
+    include Comparable
+    MAJOR_BITS = 10
+    MINOR_BITS = 10
+    PATCH_BITS = 12
+    MAJOR_MASK = (1 << MAJOR_BITS) - 1
+    MINOR_MASK = (1 << MINOR_BITS) - 1
+    PATCH_MASK = (1 << PATCH_BITS) - 1
+
+    attr_reader :major, :minor, :patch
+    def initialize(major, minor = 0, patch = 0)
+      @major = major
+      @minor = minor
+      @patch = patch
+    end
+
+    def to_int
+      Version.make(@major, @minor, @patch)
+    end
+    alias to_i to_int
+
+    def <=>(other)
+      res = (@major <=> other.major)
+      res = (@minor <=> other.minor) if res == 0
+      res = (@patch <=> other.patch) if res == 0
+      res
+    end
+
+    def to_s
+      "#{@major}.#{@minor}.#{@patch}"
+    end
+
+    def self.major(v)
+      v >> (MINOR_BITS + PATCH_BITS)
+    end
+
+    def self.minor(v)
+      (v >> (PATCH_BITS)) & MINOR_MASK
+    end
+
+    def self.patch(v)
+      v & PATCH_MASK
+    end
+
+    def self.make(major, minor = 0, patch = 0)
+      ((major & MAJOR_MASK) << (MINOR_BITS + PATCH_BITS)) +
+      ((minor & MINOR_MASK) << PATCH_BITS) +
+       (patch & PATCH_MASK)
+    end
+
+    def self.from_int(v)
+      self.new(major(v), minor(v), patch(v))
+    end
+  end
+
+  # Maps the :cl_name_version type of OpenCL
+  class NameVersion < Struct
+    MAX_NAME_SIZE = 64
+    layout :version, :cl_version,
+           :name, [:char, MAX_NAME_SIZE]
+
+    def version
+      Version.from_int(self[:version])
+    end
+
+    def name
+      self[:name].to_s
     end
   end
 
@@ -169,7 +247,7 @@ module OpenCL
       end
       return properties
     end
-  
+
     # Extracts the origin_symbol and region_symbol named options for image from the given hash. Returns the read (or detemined suitable) origin and region in a tuple
     def get_origin_region( image, options, origin_symbol, region_symbol )
       origin = MemoryPointer::new( :size_t, 3 )
@@ -214,6 +292,19 @@ module OpenCL
       return properties
     end
   
+    # EXtracts the :properties named option (for a Mem) from the hash given and returns the properties values
+    def get_mem_properties( options )
+      properties = nil
+      if options[:properties] then
+        properties = MemoryPointer::new( :cl_mem_properties, options[:properties].length + 1 )
+        options[:properties].each_with_index { |e,i|
+          properties[i].write_cl_mem_properties(e.respond_to?(:to_ptr) ? e : e.to_i)
+        }
+        properties[options[:properties].length].write_cl_mem_properties(0)
+      end
+      return properties
+    end
+  
     # Extracts the :device_list named option from the hash given and returns [ number of devices, an Pointer to the list of Device or nil ]
     def get_device_list( options )
       devices = options[:device_list]
@@ -248,6 +339,7 @@ module OpenCL
       :cl_command_queue_properties => CommandQueue::Properties,
       :cl_device_affinity_domain => Device::AffinityDomain,
       :cl_device_svm_capabilities => Device::SVMCapabilities,
+      :cl_device_atomic_capabilities => Device::AtomicCapabilities,
       :cl_channel_order => ChannelOrder,
       :cl_channel_type => ChannelType,
       :cl_mem_flags => Mem::Flags,
@@ -284,27 +376,156 @@ module OpenCL
     include InnerInterface
   end
 
+  module ExtensionInnerGenerator
+
+    private
+
+    # @!macro [attach] get_info_ext
+    #   @!method $3
+    #   Returns the OpenCL::$1::$3 info
+    #   @return $2
+    def get_info_ext(klass, type, name, function, memoizable = false)
+      if memoizable
+      s = <<EOF
+      def #{name.downcase}
+        return @_#{name.downcase} if @_#{name.downcase}
+        f = platform.get_extension_function("#{function}", :cl_int, [#{klass}, :cl_uint, :size_t, :pointer, :pointer])
+        error_check(OpenCL::INVALID_OPERATION) unless f
+
+        ptr1 = MemoryPointer::new(:size_t, 1)
+        error = f.call(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
+        error_check(error)
+        ptr2 = MemoryPointer::new(ptr1.read_size_t)
+        error = f.call(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
+        error_check(error)
+        if(convert_type(:#{type})) then
+          @_#{name.downcase} = convert_type(:#{type})::new(ptr2.read_#{type})
+        else
+          @_#{name.downcase} = ptr2.read_#{type}
+        end
+        return @_#{name.downcase}
+      end
+EOF
+      else
+      s = <<EOF
+      def #{name.downcase}
+        f = platform.get_extension_function("#{function}", :cl_int, [#{klass}, :cl_uint, :size_t, :pointer, :pointer])
+        error_check(OpenCL::INVALID_OPERATION) unless f
+
+        ptr1 = MemoryPointer::new(:size_t, 1)
+        error = f.call(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
+        error_check(error)
+        ptr2 = MemoryPointer::new(ptr1.read_size_t)
+        error = f.call(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
+        error_check(error)
+        if(convert_type(:#{type})) then
+          return convert_type(:#{type})::new(ptr2.read_#{type})
+        else
+          return ptr2.read_#{type}
+        end
+      end
+EOF
+      end
+      if type == :cl_bool then
+        s += <<EOF
+      def #{name.downcase}?
+        #{name.downcase} == 0 ? false : true
+      end
+EOF
+      end
+      module_eval s
+    end
+
+    # @!macro [attach] get_info_array_ext
+    #   @!method $3
+    #   Returns the OpenCL::$1::$3 info
+    #   @return an Array of $2
+    def get_info_array_ext(klass, type, name, function, memoizable = false)
+      if memoizable
+      s = <<EOF
+      def #{name.downcase}
+        return @_#{name.downcase} if @_#{name.downcase}
+        f = platform.get_extension_function("#{function}", :cl_int, [#{klass}, :cl_uint, :size_t, :pointer, :pointer])
+        error_check(OpenCL::INVALID_OPERATION) unless f
+
+        ptr1 = MemoryPointer::new(:size_t, 1)
+        error = f.call(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
+        error_check(error)
+        ptr2 = MemoryPointer::new(ptr1.read_size_t)
+        error = f.call(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
+        error_check(error)
+        arr = ptr2.get_array_of_#{type}(0, ptr1.read_size_t / OpenCL.find_type(:#{type}).size)
+        if(convert_type(:#{type})) then
+          @_#{name.downcase} = arr.collect { |e| convert_type(:#{type})::new(e) }
+        else
+          @_#{name.downcase} = arr
+        end
+        return @_#{name.downcase}
+      end
+EOF
+      else
+      s = <<EOF
+      def #{name.downcase}
+        f = platform.get_extension_function("#{function}", :cl_int, [#{klass}, :cl_uint, :size_t, :pointer, :pointer])
+        error_check(OpenCL::INVALID_OPERATION) unless f
+
+        ptr1 = MemoryPointer::new(:size_t, 1)
+        error = f.call(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
+        error_check(error)
+        ptr2 = MemoryPointer::new(ptr1.read_size_t)
+        error = f.call(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
+        error_check(error)
+        arr = ptr2.get_array_of_#{type}(0, ptr1.read_size_t / OpenCL.find_type(:#{type}).size)
+        if(convert_type(:#{type})) then
+          return arr.collect { |e| convert_type(:#{type})::new(e) }
+        else
+          return arr
+        end
+      end
+EOF
+      end
+      module_eval s
+    end
+
+  end
+  private_constant :ExtensionInnerGenerator
+
   module InnerGenerator
 
     private
 
-    # Generates a new method for klass that use the apropriate clGetKlassInfo, to read an info of the given type. The info queried is specified by name.
-    # @param [String] klass the property is to be found
-    # @param [Symbol] type of the property
-    # @param [String] name of the property
     # @!macro [attach] get_info
     #   @!method $3
     #   Returns the OpenCL::$1::$3 info
     #   @return $2
-    def get_info(klass, type, name)
+    def get_info(klass, type, name, memoizable = false)
       klass_name = klass
       klass_name = "MemObject" if klass == "Mem"
+      if memoizable
+      s = <<EOF
+      def #{name.downcase}
+        return @_#{name.downcase} if @_#{name.downcase}
+        ptr1 = MemoryPointer::new(:size_t, 1)
+        error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
+        error_check(error)
+        ptr2 = MemoryPointer::new(ptr1.read_size_t)
+        error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
+        error_check(error)
+        if(convert_type(:#{type})) then
+          @_#{name.downcase} = convert_type(:#{type})::new(ptr2.read_#{type})
+        else
+          @_#{name.downcase} = ptr2.read_#{type}
+        end
+        return @_#{name.downcase}
+      end
+EOF
+      else
       s = <<EOF
       def #{name.downcase}
-        ptr1 = MemoryPointer::new( :size_t, 1)
+        ptr1 = MemoryPointer::new(:size_t, 1)
         error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
         error_check(error)
-        ptr2 = MemoryPointer::new( ptr1.read_size_t )
+        ptr2 = MemoryPointer::new(ptr1.read_size_t)
         error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
         error_check(error)
         if(convert_type(:#{type})) then
@@ -314,6 +535,7 @@ module OpenCL
         end
       end
 EOF
+      end
       if type == :cl_bool then
         s += <<EOF
       def #{name.downcase}?
@@ -324,26 +546,42 @@ EOF
       module_eval s
     end
 
-    # Generates a new method for klass that use the apropriate clGetKlassInfo, to read an Array of element of the given type. The info queried is specified by name.
-    # @param [String] klass the property is to be found
-    # @param [Symbol] type of the property
-    # @param [String] name of the property
     # @!macro [attach] get_info_array
     #   @!method $3
     #   Returns the OpenCL::$1::$3 info
     #   @return an Array of $2
-    def get_info_array(klass, type, name)
+    def get_info_array(klass, type, name, memoizable = false)
       klass_name = klass
       klass_name = "MemObject" if klass == "Mem"
-      s = <<EOF
+      if memoizable
+        s = <<EOF
       def #{name.downcase}
-        ptr1 = MemoryPointer::new( :size_t, 1)
+        return @_#{name.downcase} if @_#{name.downcase}
+        ptr1 = MemoryPointer::new(:size_t, 1)
         error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
         error_check(error)
-        ptr2 = MemoryPointer::new( ptr1.read_size_t )
+        ptr2 = MemoryPointer::new(ptr1.read_size_t)
         error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
         error_check(error)
-        arr = ptr2.get_array_of_#{type}(0, ptr1.read_size_t/ OpenCL.find_type(:#{type}).size)
+        arr = ptr2.get_array_of_#{type}(0, ptr1.read_size_t / OpenCL.find_type(:#{type}).size)
+        if(convert_type(:#{type})) then
+          @_#{name.downcase} = arr.collect { |e| convert_type(:#{type})::new(e) }
+        else
+          @_#{name.downcase} = arr
+        end
+        return @_#{name.downcase}
+      end
+EOF
+      else
+        s = <<EOF
+      def #{name.downcase}
+        ptr1 = MemoryPointer::new(:size_t, 1)
+        error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
+        error_check(error)
+        ptr2 = MemoryPointer::new(ptr1.read_size_t)
+        error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
+        error_check(error)
+        arr = ptr2.get_array_of_#{type}(0, ptr1.read_size_t / OpenCL.find_type(:#{type}).size)
         if(convert_type(:#{type})) then
           return arr.collect { |e| convert_type(:#{type})::new(e) }
         else
@@ -351,6 +589,7 @@ EOF
         end
       end
 EOF
+      end
       module_eval s
     end