opencl_ruby_ffi 1.3.7 → 1.3.12

data/lib/opencl_ruby_ffi/Mem.rb

@@ -46,17 +46,17 @@ module OpenCL
 
     # Returns the Context associated to the Mem
     def context
-      return @_context if @_context
-      ptr = MemoryPointer::new( Context )
-      error = OpenCL.clGetMemObjectInfo(self, CONTEXT, Context.size, ptr, nil)
-      error_check(error)
-      @_context = Context::new( ptr.read_pointer )
+      @_context ||= begin
+       ptr = MemoryPointer::new( Context )
+        error = OpenCL.clGetMemObjectInfo(self, CONTEXT, Context.size, ptr, nil)
+        error_check(error)
+        Context::new( ptr.read_pointer )
+      end
     end
 
     # Returns the Platform associated to the Mem
     def platform
-      return @_platform if @_platform
-      @_platform = self.context.platform
+      @_platform ||= self.context.platform
     end
 
     # Returns the texture_target argument specified in create_from_GL_texture for Mem
@@ -130,11 +130,17 @@ module OpenCL
       extend InnerGenerator
 
       get_info("Mem", :cl_bool, "uses_svm_pointer", true)
+    end
+
+    module OpenCL30
+      extend InnerGenerator
 
+      get_info_array("Mem", :cl_mem_properties, "properties")
     end
 
     register_extension( :v11,  OpenCL11, "platform.version_number >= 1.1" )
     register_extension( :v20,  OpenCL20, "platform.version_number >= 2.0" )
+    register_extension( :v30,  OpenCL30, "platform.version_number >= 3.0" )
 
   end
 

data/lib/opencl_ruby_ffi/Pipe.rb

@@ -34,6 +34,14 @@ module OpenCL
     get_info("Pipe", :cl_uint, "packet_size")
     get_info("Pipe", :cl_uint, "max_packets")
 
+    module OpenCL30
+      extend InnerGenerator
+
+      get_info_array("Pipe", :cl_pipe_properties, "properties")
+    end
+
+    register_extension( :v30,  Pipe::OpenCL30, "platform.version_number >= 3.0" )
+
   end
 
 end

data/lib/opencl_ruby_ffi/Platform.rb

@@ -63,18 +63,18 @@ module OpenCL
 
   # Returns an Array of Platform containing the available OpenCL platforms
   def self.get_platforms
-    return @_platforms if @_platforms
-    ptr1 = MemoryPointer::new(:cl_uint , 1)
+    @_platforms ||= begin
+      ptr1 = MemoryPointer::new(:cl_uint , 1)
     
-    error = clGetPlatformIDs(0, nil, ptr1)
-    error_check(error)
-    ptr2 = MemoryPointer::new(:pointer, ptr1.read_uint)
-    error = clGetPlatformIDs(ptr1.read_uint(), ptr2, nil)
-    error_check(error)
-    @_platforms = ptr2.get_array_of_pointer(0,ptr1.read_uint()).collect { |platform_ptr|
-      Platform::new(platform_ptr, false)
-    }
-    return @_platforms
+      error = clGetPlatformIDs(0, nil, ptr1)
+      error_check(error)
+      ptr2 = MemoryPointer::new(:pointer, ptr1.read_uint)
+      error = clGetPlatformIDs(ptr1.read_uint(), ptr2, nil)
+      error_check(error)
+      ptr2.get_array_of_pointer(0,ptr1.read_uint()).collect { |platform_ptr|
+        Platform::new(platform_ptr, false)
+      }
+    end
   end
 
   class << self
@@ -181,8 +181,33 @@ module OpenCL
 
     end
 
+    module OpenCL30
+      extend InnerGenerator
+
+      def numeric_version
+        ptr = MemoryPointer::new( :cl_version )
+        error = OpenCL.clGetPlatformInfo( 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.clGetPlatformInfo( self, EXTENSIONS_WITH_VERSION, 0, nil, sz)
+        error_check(error)
+        sz = sz.read_size_t
+        ptr = MemoryPointer::new( sz )
+        error = OpenCL.clGetPlatformInfo( 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
+
+    end
+
     register_extension( :v12, OpenCL12, "version_number >= 1.2" )
     register_extension( :v21, OpenCL21, "version_number >= 2.1" )
+    register_extension( :v30, OpenCL30, "version_number >= 3.0" )
 
   end
 

data/lib/opencl_ruby_ffi/Program.rb

@@ -280,7 +280,11 @@ module OpenCL
       build_status.each { |d,s|
         success |= true if s.to_i == BuildStatus::SUCCESS
       }
-      return "#<#{self.class.name}: #{success ? kernel_names : ""}>"
+      begin
+        return "#<#{self.class.name}: #{success ? kernel_names : ""}>"
+      rescue
+        return "#<#{self.class.name}: >"
+      end
     end
 
     alias_method :orig_method_missing, :method_missing
@@ -304,17 +308,17 @@ module OpenCL
 
     # Returns the Platform associated with the Program
     def platform
-      return @_platform if @_platform
-      @_platform = self.context.platform
+      @_platform ||= self.context.platform
     end
 
     # Returns the Context the Program is associated to
     def context
-      return @_context if @_context
-      ptr = MemoryPointer::new( Context )
-      error = OpenCL.clGetProgramInfo(self, CONTEXT, Context.size, ptr, nil)
-      error_check(error)
-      @_context = Context::new( ptr.read_pointer )
+      @_context ||= begin
+        ptr = MemoryPointer::new( Context )
+        error = OpenCL.clGetProgramInfo(self, CONTEXT, Context.size, ptr, nil)
+        error_check(error)
+        Context::new( ptr.read_pointer )
+      end
     end
 
     get_info("Program", :cl_uint, "num_devices", true)
@@ -322,15 +326,15 @@ module OpenCL
 
     # Returns the Array of Device the Program is associated with
     def devices
-      return @_devices if @_devices
-      n = self.num_devices
-      ptr2 = MemoryPointer::new( Device, n )
-      error = OpenCL.clGetProgramInfo(self, DEVICES, Device.size*n, ptr2, nil)
-      error_check(error)
-      @_devices = ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
-        Device::new(device_ptr)
-      }
-      return @_devices
+      @_devices ||= begin
+        n = self.num_devices
+        ptr2 = MemoryPointer::new( Device, n )
+        error = OpenCL.clGetProgramInfo(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
 
     get_info("Program", :string, "source")

data/lib/opencl_ruby_ffi/SVM.rb

@@ -158,7 +158,7 @@ module OpenCL
   # ==== Returns
   #
   # the Event associated with the command
-  def self.enqueue_svm_memfill(command_queue, svm_ptr, pattern, size, options = {})
+  def self.enqueue_svm_memfill(command_queue, svm_ptr, pattern, options = {})
     error_check(INVALID_OPERATION) if command_queue.context.platform.version_number < 2.0
     num_events, events = get_event_wait_list( options )
     pattern_size = pattern.size

data/lib/opencl_ruby_ffi/Sampler.rb

@@ -30,7 +30,7 @@ module OpenCL
       prop_size += 2 if options[:mip_filter_mode]
       prop_size += 2 if options[:lod_min]
       prop_size += 2 if options[:lod_max]
-      properties = MemoryPointer::new( :cl_sampler_info )
+      properties = MemoryPointer::new( :cl_sampler_properties, prop_size )
       properties[0].write_cl_sampler_info( Sampler::NORMALIZED_COORDS )
       properties[1].write_cl_bool( normalized_coords )
       properties[2].write_cl_sampler_info( Sampler::ADDRESSING_MODE )
@@ -71,11 +71,12 @@ module OpenCL
 
     # Returns the context associated with the Sampler
     def context
-      return @_context if @_context
-      ptr = MemoryPointer::new( Context )
-      error = OpenCL.clGetSamplerInfo(self, CONTEXT, Context.size, ptr, nil)
-      error_check(error)
-      @_context = Context::new( ptr.read_pointer )
+      @_context ||= begin
+        ptr = MemoryPointer::new( Context )
+        error = OpenCL.clGetSamplerInfo(self, CONTEXT, Context.size, ptr, nil)
+        error_check(error)
+        Context::new( ptr.read_pointer )
+      end
     end
 
     get_info("Sampler", :cl_uint, "reference_count")

data/lib/opencl_ruby_ffi/ext.rb

@@ -9,3 +9,4 @@ require "opencl_ruby_ffi/ext/device_fission.rb"
 require "opencl_ruby_ffi/khr/sub_groups.rb"
 require "opencl_ruby_ffi/khr/priority_hints.rb"
 require "opencl_ruby_ffi/khr/throttle_hints.rb"
+require "opencl_ruby_ffi/khr/device_uuid.rb"

data/lib/opencl_ruby_ffi/intel/unified_shared_memory_preview.rb

@@ -228,6 +228,23 @@ module OpenCL
       get_info("Device", :cl_unified_shared_memory_capabilities_intel, "device_shared_mem_capabilities_intel")
       get_info("Device", :cl_unified_shared_memory_capabilities_intel, "cross_device_mem_capabilities_intel")
       get_info("Device", :cl_unified_shared_memory_capabilities_intel, "shared_system_mem_capabilities_intel")
+
+      def clGetDeviceGlobalVariablePointerINTEL
+        @_clGetDeviceGlobalVariablePointerINTEL ||= begin
+          p = platform.get_extension_function("clGetDeviceGlobalVariablePointerINTEL", :cl_int, [Device, Program, :string, :pointer, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
+      end
+
+      def get_global_variable_pointer_intel(program, name)
+        pSize = MemoryPointer::new(:size_t)
+        pAddr = MemoryPointer::new(:pointer)
+        error = clGetDeviceGlobalVariablePointerINTEL.call(self, program, name, pSize, pAddr)
+        error_check(error)
+        return USMPointer::new(pAddr.read_pointer.slice(0, pSize.read_size_t), self)
+      end
+
     end
     register_extension( :cl_intel_unified_shared_memory_preview, UnifiedSharedMemoryPreviewINTEL, "extensions.include?(\"cl_intel_unified_shared_memory_preview\")" )
   end
@@ -282,38 +299,43 @@ module OpenCL
       extend InnerGenerator
 
       def clGetMemAllocInfoINTEL
-        return @_clGetMemAllocInfoINTEL if @_clGetMemAllocInfoINTEL
-        @_clGetMemAllocInfoINTEL = platform.get_extension_function("clGetMemAllocInfoINTEL", :cl_int, [Context, :pointer, :cl_mem_info_intel, :size_t, :pointer, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clGetMemAllocInfoINTEL
-        return @_clGetMemAllocInfoINTEL
+        @_clGetMemAllocInfoINTEL ||= begin
+          p = platform.get_extension_function("clGetMemAllocInfoINTEL", :cl_int, [Context, :pointer, :cl_mem_info_intel, :size_t, :pointer, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def clHostMemAllocINTEL
-        return @_clHostMemAllocINTEL if @_clHostMemAllocINTEL
-        @_clHostMemAllocINTEL = platform.get_extension_function("clHostMemAllocINTEL", :pointer, [Context, :pointer, :size_t, :cl_uint, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clHostMemAllocINTEL
-        return @_clHostMemAllocINTEL
+        @_clHostMemAllocINTEL ||= begin
+          p = platform.get_extension_function("clHostMemAllocINTEL", :pointer, [Context, :pointer, :size_t, :cl_uint, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def clDeviceMemAllocINTEL
-        return @_clDeviceMemAllocINTEL if @_clDeviceMemAllocINTEL
-        @_clDeviceMemAllocINTEL = platform.get_extension_function("clDeviceMemAllocINTEL", :pointer, [Context, Device, :pointer, :size_t, :cl_uint, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clDeviceMemAllocINTEL
-        return @_clDeviceMemAllocINTEL
+        @_clDeviceMemAllocINTEL ||= begin
+          p = platform.get_extension_function("clDeviceMemAllocINTEL", :pointer, [Context, Device, :pointer, :size_t, :cl_uint, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def clSharedMemAllocINTEL
-        return @_clSharedMemAllocINTEL if @_clSharedMemAllocINTEL
-        @_clSharedMemAllocINTEL = platform.get_extension_function("clSharedMemAllocINTEL", :pointer, [Context, Device, :pointer, :size_t, :cl_uint, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clSharedMemAllocINTEL
-        return @_clSharedMemAllocINTEL
+        @_clSharedMemAllocINTEL ||= begin
+          p = platform.get_extension_function("clSharedMemAllocINTEL", :pointer, [Context, Device, :pointer, :size_t, :cl_uint, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def clMemFreeINTEL
-        return @_clMemFreeINTEL if @_clMemFreeINTEL
-        @_clMemFreeINTEL = platform.get_extension_function("clMemFreeINTEL", :cl_int, [Context, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clMemFreeINTEL
-        return @_clMemFreeINTEL
+        return @_clMemFreeINTEL ||= begin
+          p = platform.get_extension_function("clMemFreeINTEL", :cl_int, [Context, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def get_mem_properties_intel(properties)
@@ -414,10 +436,11 @@ module OpenCL
       extend InnerGenerator
 
       def clSetKernelArgMemPointerINTEL
-        return @_clSetKernelArgMemPointerINTEL if @_clSetKernelArgMemPointerINTEL
-        @_clSetKernelArgMemPointerINTEL = context.platform.get_extension_function("clSetKernelArgMemPointerINTEL", :cl_int, Kernel, :cl_uint, :pointer)
-        error_check(OpenCL::INVALID_OPERATION) unless @_clSetKernelArgMemPointerINTEL
-        return @_clSetKernelArgMemPointerINTEL
+        @_clSetKernelArgMemPointerINTEL ||= begin
+          p = context.platform.get_extension_function("clSetKernelArgMemPointerINTEL", :cl_int, Kernel, :cl_uint, :pointer)
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def set_arg_mem_pointer_intel(index, usm_pointer)
@@ -508,31 +531,35 @@ module OpenCL
       extend InnerGenerator
 
       def clEnqueueMemFillINTEL
-        return @_clEnqueueMemFillINTEL if @_clEnqueueMemFillINTEL
-        @_clEnqueueMemFillINTEL = platform.get_extension_function("clEnqueueMemFillINTEL", :cl_int, [CommandQueue, :pointer, :pointer, :size_t, :size_t, :cl_uint, :pointer, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clEnqueueMemFillINTEL
-        return @_clEnqueueMemFillINTEL
+        @_clEnqueueMemFillINTEL ||= begin
+          p = platform.get_extension_function("clEnqueueMemFillINTEL", :cl_int, [CommandQueue, :pointer, :pointer, :size_t, :size_t, :cl_uint, :pointer, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def clEnqueueMemcpyINTEL
-        return @_clEnqueueMemcpyINTEL if @_clEnqueueMemcpyINTEL
-        @_clEnqueueMemcpyINTEL = platform.get_extension_function("clEnqueueMemcpyINTEL", :cl_int, [CommandQueue, :cl_bool, :pointer, :pointer, :size_t, :cl_uint, :pointer, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clEnqueueMemcpyINTEL
-        return @_clEnqueueMemcpyINTEL
+        @_clEnqueueMemcpyINTEL ||= begin
+          p = platform.get_extension_function("clEnqueueMemcpyINTEL", :cl_int, [CommandQueue, :cl_bool, :pointer, :pointer, :size_t, :cl_uint, :pointer, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def clEnqueueMigrateMemINTEL
-        return @_clEnqueueMigrateMemINTEL if @_clEnqueueMigrateMemINTEL
-        @_clEnqueueMigrateMemINTEL = platform.get_extension_function("clEnqueueMigrateMemINTEL", :cl_int, [CommandQueue, :pointer, :size_t, :cl_mem_migration_flags_intel, :cl_uint, :pointer, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clEnqueueMemcpyINTEL
-        return @_clEnqueueMemcpyINTEL
+        @_clEnqueueMigrateMemINTEL ||= begin
+          p = platform.get_extension_function("clEnqueueMigrateMemINTEL", :cl_int, [CommandQueue, :pointer, :size_t, :cl_mem_migration_flags_intel, :cl_uint, :pointer, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def clEnqueueMemAdviseINTEL
-        return @_clEnqueueMemAdviseINTEL if @_clEnqueueMemAdviseINTEL
-        @_clEnqueueMemAdviseINTEL = platform.get_extension_function("clEnqueueMemAdviseINTEL", :cl_int, [CommandQueue, :pointer, :size_t, :cl_mem_advice_intel, :cl_uint, :pointer, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clEnqueueMemAdviseINTEL
-        return @_clEnqueueMemAdviseINTEL
+        @_clEnqueueMemAdviseINTEL ||= begin
+          p = platform.get_extension_function("clEnqueueMemAdviseINTEL", :cl_int, [CommandQueue, :pointer, :size_t, :cl_mem_advice_intel, :cl_uint, :pointer, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def enqueue_mem_fill_intel(usm_ptr, pattern, options = {})

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