opencl_ruby_ffi 1.3.4 → 1.3.9

data/lib/opencl_ruby_ffi/SVM.rb

@@ -5,7 +5,7 @@ module OpenCL
   class SVMPointer < Pointer
 
     # create a new SVMPointer from its address and the context it pertains to
-    def initialize( address, context, size, base = nil )
+    def initialize( address, context, base = nil )
       super( address )
       @context = context
       if base then
@@ -13,16 +13,20 @@ module OpenCL
       else
         @base = address
       end
-      @size = size
     end
 
     def inspect
-      return "#<#{self.class.name}: #{@size}>"
+      return "#<#{self.class.name}: 0x#{address.to_s(16)} (#{size})>"
+    end
+
+    def slice(offset, size)
+      res = super(offset, size)
+      return slef.class.new( res, @context, @base )
     end
 
     # creates a new SVMPointer relative to an existing one from an offset
     def +( offset )
-      return SVMPointer::new(  self.address + offset, @context, @size, @base )
+      self.slice(offset, self.size - offset)
     end
 
     # frees the parent memory region associated to this SVMPointer
@@ -51,7 +55,7 @@ module OpenCL
     alignment = options[:alignment] if options[:alignment]
     ptr = clSVMAlloc( context, flags, size, alignment )
     error_check(MEM_OBJECT_ALLOCATION_FAILURE) if ptr.null?
-    return SVMPointer::new( ptr, context, size )
+    return SVMPointer::new( ptr.slice(0, size), context )
   end
 
   # Frees an SVMPointer
@@ -112,11 +116,11 @@ module OpenCL
   # * +command_queue+ - CommandQueue used to execute the write command
   # * +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
@@ -124,10 +128,12 @@ module OpenCL
   # ==== Returns
   #
   # the Event associated with the command
-  def self.enqueue_svm_memcpy(command_queue, dst_ptr, src_ptr, size, options = {})
+  def self.enqueue_svm_memcpy(command_queue, dst_ptr, src_ptr, options = {})
     error_check(INVALID_OPERATION) if command_queue.context.platform.version_number < 2.0
     blocking = FALSE
     blocking = TRUE if options[:blocking] or options[:blocking_copy]
+    size = [dst_ptr.size, src_ptr.size].min
+    size = options[:size] if options[:size]
     num_events, events = get_event_wait_list( options )
     event = MemoryPointer::new( Event )
     error = clEnqueueSVMMemcpy(command_queue, blocking, dst_ptr, src_ptr, size, num_events, events, event)
@@ -142,10 +148,10 @@ module OpenCL
   # * +command_queue+ - CommandQueue used to execute the write command
   # * +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
   #
@@ -157,24 +163,28 @@ module OpenCL
     num_events, events = get_event_wait_list( options )
     pattern_size = pattern.size
     pattern_size = options[:pattern_size] if options[:pattern_size]
+    size = svm_ptr.size
+    size = options[:size] if options[:size]
     event = MemoryPointer::new( Event )
     error = clEnqueueSVMMemFill(command_queue, svm_ptr, pattern, pattern_size, size, num_events, events, event)
     error_check(error)
     return Event::new(event.read_pointer, false)
   end
 
+  singleton_class.send(:alias_method, :enqueue_svm_mem_fill, :enqueue_svm_memfill)
+
   # Enqueues a command to map an Image into host memory
   #
   # ==== Attributes
   # 
   # * +command_queue+ - CommandQueue used to execute the map command
   # * +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
@@ -182,11 +192,13 @@ module OpenCL
   # ==== Returns
   #
   # the Event associated with the command
-  def self.enqueue_svm_map( command_queue, svm_ptr, size, map_flags, options = {} )
+  def self.enqueue_svm_map( command_queue, svm_ptr, map_flags, options = {} )
     error_check(INVALID_OPERATION) if command_queue.context.platform.version_number < 2.0
     blocking = FALSE
     blocking = TRUE if options[:blocking] or options[:blocking_map]
     flags = get_flags( {:flags => map_flags} )
+    size = svm_ptr.size
+    size = options[:size] if options[:size]
     num_events, events = get_event_wait_list( options )
     event = MemoryPointer::new( Event )
     error = clEnqueueSVMMap( command_queue, blocking, flags, svm_ptr, size, num_events, events, event )
@@ -251,7 +263,7 @@ module OpenCL
       sizes_p[i].write_size_t(sizes[i])
     }
     event = MemoryPointer::new( Event )
-    error =  clEnqueueSVMMigrateMem( command_queue, num_svm_pointers, svn_ptrs_p, sizes_p, flags, num_events, events, event )
+    error = clEnqueueSVMMigrateMem( command_queue, num_svm_pointers, svn_ptrs_p, sizes_p, flags, num_events, events, event )
     error_check( error )
     return Event::new( event.read_pointer, false )
   end

data/lib/opencl_ruby_ffi/Sampler.rb

@@ -71,10 +71,11 @@ 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)
-      return Context::new( ptr.read_pointer )
+      @_context = Context::new( ptr.read_pointer )
     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/accelerator.rb

@@ -0,0 +1,152 @@
+module OpenCL
+
+  ACCELERATOR_DESCRIPTOR_INTEL = 0x4090
+  ACCELERATOR_REFERENCE_COUNT_INTEL = 0x4091
+  ACCELERATOR_CONTEXT_INTEL = 0x4092
+  ACCELERATOR_TYPE_INTEL = 0x4093
+  INVALID_ACCELERATOR_INTEL = -1094
+  INVALID_ACCELERATOR_TYPE_INTEL = -1095
+  INVALID_ACCELERATOR_DESCRIPTOR_INTEL = -1096
+  ACCELERATOR_TYPE_NOT_SUPPORTED_INTEL = -1097
+
+  typedef :cl_uint, :cl_accelerator_type_intel
+  typedef :cl_uint, :cl_accelerator_info_intel
+
+end
+
+if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+  module OpenCLRefinements
+    refine FFI::Pointer do
+      methods_prefix = [:put, :get, :write, :read, :put_array_of, :get_array_of]
+      [[:cl_uint, :cl_accelerator_type_intel],
+       [:cl_uint, :cl_accelerator_info_intel]].each { |orig, add|
+        methods_prefix.each { |meth|
+          alias_method "#{meth}_#{add}".to_sym, "#{meth}_#{orig}".to_sym
+        }
+      }
+    end
+  end
+  using OpenCLRefinements
+else
+  class FFI::Pointer
+    methods_prefix = [:put, :get, :write, :read, :put_array_of, :get_array_of]
+    [[:cl_uint, :cl_accelerator_type_intel],
+     [:cl_uint, :cl_accelerator_info_intel]].each { |orig, add|
+      methods_prefix.each { |meth|
+          alias_method "#{meth}_#{add}".to_sym, "#{meth}_#{orig}".to_sym
+      }
+    }
+  end
+end
+
+module OpenCL
+
+  class Error
+    eval error_class_constructor( :INVALID_ACCELERATOR_INTEL, :InvalidAcceleratorINTEL )
+    eval error_class_constructor( :INVALID_ACCELERATOR_TYPE_INTEL, :InvalidAcceleratorTypeINTEL )
+    eval error_class_constructor( :INVALID_ACCELERATOR_DESCRIPTOR_INTEL, :InvalidAcceleratorDescriptorINTEL )
+    eval error_class_constructor( :ACCELERATOR_TYPE_NOT_SUPPORTED_INTEL, :AcceleratorTypeNotSupportedINTEL )
+  end
+
+  class AcceleratorINTEL < ExtendedStruct
+    class AcceleratorINTELPointer < FFI::Pointer
+      attr_accessor :context
+      def initialize(ptr, context)
+        super(ptr)
+        @context = context
+      end
+    end
+
+    include InnerInterface
+    extend ExtensionInnerGenerator
+    layout :dummy, :pointer
+    DESCRIPTOR_INTEL = 0x4090
+    REFERENCE_COUNT_INTEL = 0x4091
+    CONTEXT_INTEL = 0x4092
+    TYPE_INTEL = 0x4093
+
+    def platform
+      @context.platform
+    end
+
+    def initialize(ptr, context = ptr.context, retain = true)
+      super(AcceleratorINTELPointer::new(ptr, context))
+      @context = context
+      context.__retain_accelerator_intel(ptr) if retain
+    end
+
+    def self.release(ptr)
+      ptr.context.__release_accelerator_intel(ptr)
+    end
+
+    def descriptor_intel
+      f = platform.get_extension_function("clGetAcceleratorInfoINTEL", :cl_int,
+            [OpenCL::AcceleratorINTEL, :cl_accelerator_info_intel, :size_t, :pointer, :pointer])
+      error_check(OpenCL::INVALID_OPERATION) unless f
+
+      ptr1 = MemoryPointer::new( :size_t, 1)
+      error = f.call(self, DESCRIPTOR_INTEL, 0, nil, ptr1)
+      error_check(error)
+      ptr2 = MemoryPointer::new( ptr1.read_size_t )
+      error = f.call(self, DESCRIPTOR_INTEL, ptr1.read_size_t, ptr2, nil)
+      error_check(error)
+      return ptr2
+    end
+
+    def context_intel
+      f = platform.get_extension_function("clGetAcceleratorInfoINTEL", :cl_int,
+            [OpenCL::AcceleratorINTEL, :cl_accelerator_info_intel, :size_t, :pointer, :pointer])
+      error_check(OpenCL::INVALID_OPERATION) unless f
+
+      ptr = MemoryPointer::new( Context )
+      error = f.call(self, CONTEXT_INTEL, Context.size, ptr, nil)
+      error_check(error)
+      return Context::new( ptr.read_pointer )
+    end
+
+    get_info_ext("AcceleratorINTEL", :cl_uint, "reference_count_intel", "clGetAcceleratorInfoINTEL")
+    get_info_ext("AcceleratorINTEL", :cl_uint, "type_intel", "clGetAcceleratorInfoINTEL")
+
+  end
+
+  class Context
+    module AcceleratorINTEL
+
+      def create_accelerator_intel(accelerator_type, descriptor, options = {})
+        name = "clCreateAcceleratorINTEL"
+        return_type = OpenCL::AcceleratorINTEL
+        params = [Context, :cl_accelerator_type_intel, :size_t, :pointer, :pointer]
+        f = platform.get_extension_function(name, return_type, params)
+        error_check(OpenCL::INVALID_OPERATION) unless f
+        error = MemoryPointer::new( :cl_int )
+        size = descriptor.size
+        acc = f.call(self, accelerator_type, size, descriptor, error)
+        error_check(error.read_cl_int)
+        return OpenCL::AcceleratorINTEL::new( acc, self, false )
+      end
+
+      def __release_accelerator_intel(ptr)
+        name = "clReleaseAcceleratorINTEL"
+        return_type = :cl_int
+        params = [OpenCL::AcceleratorINTEL]
+        f = platform.get_extension_function(name, return_type, params)
+        error_check(OpenCL::INVALID_OPERATION) unless f
+        error = f.call(ptr)
+        error_check(error)
+      end
+
+      def __retain_accelerator_intel(ptr)
+        name = "clRetainAcceleratorINTEL"
+        return_type = :cl_int
+        params = [OpenCL::AcceleratorINTEL]
+        f = platform.get_extension_function(name, return_type, params)
+        error_check(OpenCL::INVALID_OPERATION) unless f
+        error = f.call(ptr)
+        error_check(error)
+      end
+
+    end
+    register_extension( :cl_intel_accelerator, AcceleratorINTEL, "platform.extensions.include?(\"cl_intel_accelerator\")" )
+  end
+
+end

data/lib/opencl_ruby_ffi/intel/advanced_motion_estimation.rb

@@ -0,0 +1,65 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+require_relative 'motion_estimation'
+
+module OpenCL
+
+  DEVICE_ME_VERSION_INTEL = 0x407E
+
+  ME_CHROMA_INTRA_PREDICT_ENABLED_INTEL = 0x1
+  ME_LUMA_INTRA_PREDICT_ENABLED_INTEL = 0x2
+
+  ME_SKIP_BLOCK_TYPE_16x16_INTEL = 0x0
+  ME_SKIP_BLOCK_TYPE_8x8_INTEL = 0x4
+
+  ME_COST_PENALTY_NONE_INTEL = 0x0
+  ME_COST_PENALTY_LOW_INTEL = 0x1
+  ME_COST_PENALTY_NORMAL_INTEL = 0x2
+  ME_COST_PENALTY_HIGH_INTEL = 0x3
+
+  ME_COST_PRECISION_QPEL_INTEL = 0x0
+  ME_COST_PRECISION_HEL_INTEL = 0x1
+  ME_COST_PRECISION_PEL_INTEL = 0x2
+  ME_COST_PRECISION_DPEL_INTEL = 0x3
+
+  ME_LUMA_PREDICTOR_MODE_VERTICAL_INTEL = 0x0
+  ME_LUMA_PREDICTOR_MODE_HORIZONTAL_INTEL = 0x1
+  ME_LUMA_PREDICTOR_MODE_DC_INTEL = 0x2
+  ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_LEFT_INTEL = 0x3
+
+  ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_RIGHT_INTEL = 0x4
+  ME_LUMA_PREDICTOR_MODE_PLANE_INTEL = 0x4
+  ME_LUMA_PREDICTOR_MODE_VERTICAL_RIGHT_INTEL = 0x5
+  ME_LUMA_PREDICTOR_MODE_HORIZONTAL_DOWN_INTEL = 0x6
+  ME_LUMA_PREDICTOR_MODE_VERTICAL_LEFT_INTEL = 0x7
+  ME_LUMA_PREDICTOR_MODE_HORIZONTAL_UP_INTEL = 0x8
+
+  ME_CHROMA_PREDICTOR_MODE_DC_INTEL = 0x0
+  ME_CHROMA_PREDICTOR_MODE_HORIZONTAL_INTEL = 0x1
+  ME_CHROMA_PREDICTOR_MODE_VERTICAL_INTEL = 0x2
+  ME_CHROMA_PREDICTOR_MODE_PLANE_INTEL = 0x3
+
+  ME_VERSION_LEGACY_INTEL = 0x0
+  ME_VERSION_ADVANCED_VER_1_INTEL = 0x1
+  ME_VERSION_ADVANCED_VER_2_INTEL = 0x2
+
+  ME_FORWARD_INPUT_MODE_INTEL = 0x1
+  ME_BACKWARD_INPUT_MODE_INTEL = 0x2
+  ME_BIDIRECTION_INPUT_MODE_INTEL = 0x3
+
+  ME_BIDIR_WEIGHT_QUARTER_INTEL = 0x10
+  ME_BIDIR_WEIGHT_THIRD_INTEL = 0x15
+  ME_BIDIR_WEIGHT_HALF_INTEL = 0x20
+  ME_BIDIR_WEIGHT_TWO_THIRD_INTEL = 0x2B
+  ME_BIDIR_WEIGHT_THREE_QUARTER_INTEL = 0x30
+
+  class Device
+    ME_VERSION_INTEL = 0x407E
+    module AdvanceMotionEstimationINTEL
+      extend InnerGenerator
+      get_info("Device", :cl_uint, "me_version_intel")
+
+    end
+    register_extension( :cl_intel_advanced_motion_estimation, AdvanceMotionEstimationINTEL, "platform.extensions.include?(\"cl_intel_advanced_motion_estimation\")" )
+  end
+end

data/lib/opencl_ruby_ffi/intel/driver_diagnostics.rb

@@ -0,0 +1,19 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+  CONTEXT_DRIVER_DIAGNOSTICS_INTEL = 0x4106
+  CONTEXT_SHOW_DIAGNOSTICS_INTEL = 0x4106
+  CONTEXT_DIAGNOSTICS_LEVEL_GOOD_INTEL = 0x1
+  CONTEXT_DIAGNOSTICS_LEVEL_BAD_INTEL = 0x2
+  CONTEXT_DIAGNOSTICS_LEVEL_NEUTRAL_INTEL = 0x4
+
+  class Context
+    DRIVER_DIAGNOSTICS_INTEL = 0x4106
+    SHOW_DIAGNOSTICS_INTEL = 0x4106
+    DIAGNOSTICS_LEVEL_GOOD_INTEL = 0x1
+    DIAGNOSTICS_LEVEL_BAD_INTEL = 0x2
+    DIAGNOSTICS_LEVEL_NEUTRAL_INTEL = 0x4
+    
+  end
+
+end

data/lib/opencl_ruby_ffi/intel/kernel_profiling.rb

@@ -0,0 +1,38 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+module OpenCL
+
+  CONTEXT_KERNEL_PROFILING_MODES_COUNT_INTEL = 0x407A
+  CONTEXT_KERNEL_PROFILING_MODE_INFO_INTEL = 0x407B
+  KERNEL_IL_SYMBOLS_INTEL = 0x407C
+  KERNEL_BINARY_PROGRAM_INTEL = 0x407D
+
+  class Kernel
+    IL_SYMBOLS_INTEL = 0x407C
+    BINARY_PROGRAM_INTEL = 0x407D
+    module KernelProfilingINTEL
+      def binary_program_intel(device = program.devices.first)
+        ptr_bin = nil
+        begin
+        ptr = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetKernelWorkGroupInfo(self, device, BINARY_PROGRAM_INTEL, 0, nil, ptr)
+        error_check(error)
+        bin_size = ptr.read_size_t
+        ptr_bin = MemoryPointer::new(bin_size)
+        error = OpenCL.clGetKernelWorkGroupInfo(self, device, BINARY_PROGRAM_INTEL, bin_size, ptr_bin, nil)
+        error_check(error)
+        rescue OpenCL::Error::INVALID_VALUE
+          ptr = MemoryPointer::new( :size_t )
+          error = OpenCL.clGetKernelInfo(self, BINARY_PROGRAM_INTEL, 0, nil, ptr)
+          error_check(error)
+          bin_size = ptr.read_size_t
+          ptr_bin = MemoryPointer::new(bin_size)
+          error = OpenCL.clGetKernelInfo(self, BINARY_PROGRAM_INTEL, bin_size, ptr_bin, nil)
+          error_check(error)
+        end
+        return ptr_bin.read_bytes(bin_size)
+      end
+    end
+    register_extension(:cl_intel_kernel_profiling, KernelProfilingINTEL, "true")
+  end
+
+end

data/lib/opencl_ruby_ffi/intel/motion_estimation.rb

@@ -0,0 +1,26 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+require_relative 'accelerator'
+
+module OpenCL
+  ACCELERATOR_TYPE_MOTION_ESTIMATION_INTEL = 0x0
+  ME_MB_TYPE_16x16_INTEL = 0x0
+  ME_MB_TYPE_8x8_INTEL = 0x1
+  ME_MB_TYPE_4x4_INTEL = 0x2
+  ME_SUBPIXEL_MODE_INTEGER_INTEL = 0x0
+  ME_SUBPIXEL_MODE_HPEL_INTEL = 0x1
+  ME_SUBPIXEL_MODE_QPEL_INTEL = 0x2
+  ME_SAD_ADJUST_MODE_NONE_INTEL = 0x0
+  ME_SAD_ADJUST_MODE_HAAR_INTEL = 0x1
+  ME_SEARCH_PATH_RADIUS_2_2_INTEL = 0x0
+  ME_SEARCH_PATH_RADIUS_4_4_INTEL = 0x1
+  ME_SEARCH_PATH_RADIUS_16_12_INTEL = 0x5
+
+  class MotionEstimationDescINTEL < FFI::Struct
+    layout :mb_block_type, :cl_uint,
+           :subpixel_mode, :cl_uint,
+           :sad_adjust_mode, :cl_uint,
+           :search_path_type, :cl_uint
+  end
+
+end