opencl_ruby_ffi 1.3.4 → 1.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b21d6823d5293898d032505607499b748d65fc45c30b0ba11d618210630a6c0
-  data.tar.gz: a6439a7eb8f5fbb3f4555ac735b271053ceedc3e5b0367bab14952fb857cdd4d
+  metadata.gz: 406f911ff3d3ea9c5f815c7854ea7cd3e4879c51dc583df94fcf73adf0532c6b
+  data.tar.gz: 4cc80ef3c64b55142ee8f6db0786b7f9d2062104e8d17df32077545e9dd41bbc
 SHA512:
-  metadata.gz: 32995522c19c6180d34879752bab8613f3f0caf9049fa4a10ecb2ab692a46ac6df3a68b122d39e7bb6df44fe4327410cc229127d515be561dea722f4b85cd3b0
-  data.tar.gz: b2e8933cc719de81412adc6ee3864547f0308b9ae959bf93f8d0806019ffe7c835cea8530dbbc43e84b6a84d4d66b87de6619b3d32089595312870c473efc615
+  metadata.gz: cd58bb929a02b1c730f7319bb45fb0f3955e1afc90b5dbb3a1c201439f9cd50dec7fd647843064c097f011725540f69f6fa40455a418398b16c470606780fd55
+  data.tar.gz: b08e3de035ec44212bd1841fcf0464cd17b4ecb6eb5712728c5a99df5cf06f044b56e2578ef0377179bd3fa973c1c8787d86ea70b46e86a784f0cbea84e03d1b

data/lib/opencl_ruby_ffi/CommandQueue.rb

@@ -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 )

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/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

data/lib/opencl_ruby_ffi/opencl_ruby_ffi_base.rb

@@ -284,6 +284,84 @@ module OpenCL
     include InnerInterface
   end
 
+  module ExtensionInnerGenerator
+
+    private
+    # Generates a new method for klass that use the given clGetKlassInfo on the object platform, 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_ext(klass, type, name, function)
+      klass_name = klass
+      klass_name = "MemObject" if klass == "Mem"
+      s = <<EOF
+      def #{name.downcase}
+        f = platform.get_extension_function("#{function}", :cl_int, [#{klass_name}, :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
+      if type == :cl_bool then
+        s += <<EOF
+      def #{name.downcase}?
+        #{name.downcase} == 0 ? false : true
+      end
+EOF
+      end
+      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_ext(klass, type, name, function)
+      klass_name = klass
+      klass_name = "MemObject" if klass == "Mem"
+      s = <<EOF
+      def #{name.downcase}
+        f = platform.get_extension_function("#{function}", :cl_int, [: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
+      module_eval s
+    end
+
+  end
+  private_constant :ExtensionInnerGenerator
+
   module InnerGenerator
 
     private

data/lib/opencl_ruby_ffi/opencl_ruby_ffi_base_gen.rb

@@ -1844,9 +1844,9 @@ EOF
   attach_function :clGetPlatformInfo, [Platform,:cl_platform_info,:size_t,:pointer,:pointer], :cl_int
   attach_function :clGetDeviceIDs, [Platform,:cl_device_type,:cl_uint,:pointer,:pointer], :cl_int
   attach_function :clGetDeviceInfo, [Device,:cl_device_info,:size_t,:pointer,:pointer], :cl_int
-  callback :clCreateContext_notify, [:pointer,:pointer,:size_t,:pointer], :void
+  callback :clCreateContext_notify, [:string,:pointer,:size_t,:pointer], :void
   attach_function :clCreateContext, [:pointer,:cl_uint,:pointer,:clCreateContext_notify,:pointer,:pointer], Context
-  callback :clCreateContextFromType_notify, [:pointer,:pointer,:size_t,:pointer], :void
+  callback :clCreateContextFromType_notify, [:string,:pointer,:size_t,:pointer], :void
   attach_function :clCreateContextFromType, [:pointer,:cl_device_type,:clCreateContextFromType_notify,:pointer,:pointer], Context
   attach_function :clRetainContext, [Context], :cl_int
   attach_function :clReleaseContext, [Context], :cl_int

data/opencl_ruby_ffi.gemspec

@@ -1,12 +1,12 @@
 Gem::Specification.new do |s|
   s.name = 'opencl_ruby_ffi'
-  s.version = "1.3.4"
+  s.version = "1.3.5"
   s.author = "Brice Videau"
   s.email = "brice.videau@imag.fr"
   s.homepage = "https://github.com/Nanosim-LIG/opencl-ruby"
   s.summary = "Ruby OpenCL FFI bindings"
-  s.description = "Ruby OpenCL FFI bindings. OpenCL 2.1 ready"
-  s.files =  Dir[ 'opencl_ruby_ffi.gemspec', 'LICENSE', 'lib/**/**/*', '.yardopts', 'templates_custom/default/module/setup.rb' ]
+  s.description = "Ruby OpenCL FFI bindings. OpenCL 2.2 ready"
+  s.files =  Dir[ 'opencl_ruby_ffi.gemspec', 'LICENSE', 'lib/**/**/*.rb', '.yardopts', 'templates_custom/default/module/setup.rb' ]
   s.has_rdoc = false
   s.license = 'BSD-2-Clause'
   s.required_ruby_version = '>= 1.8.7'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opencl_ruby_ffi
 version: !ruby/object:Gem::Version
-  version: 1.3.4
+  version: 1.3.5
 platform: ruby
 authors:
 - Brice Videau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-05 00:00:00.000000000 Z
+date: 2019-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -70,7 +70,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.0
-description: Ruby OpenCL FFI bindings. OpenCL 2.1 ready
+description: Ruby OpenCL FFI bindings. OpenCL 2.2 ready
 email: brice.videau@imag.fr
 executables: []
 extensions: []
@@ -97,6 +97,10 @@ files:
 - lib/opencl_ruby_ffi/ext.rb
 - lib/opencl_ruby_ffi/ext/device_fission.rb
 - lib/opencl_ruby_ffi/gl_ext.rb
+- lib/opencl_ruby_ffi/intel/accelerator.rb
+- lib/opencl_ruby_ffi/intel/advanced_motion_estimation.rb
+- lib/opencl_ruby_ffi/intel/driver_diagnostics.rb
+- lib/opencl_ruby_ffi/intel/motion_estimation.rb
 - lib/opencl_ruby_ffi/khr/d3d10_sharing.rb
 - lib/opencl_ruby_ffi/khr/d3d11_sharing.rb
 - lib/opencl_ruby_ffi/khr/dx9_media_sharing.rb
@@ -140,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: Ruby OpenCL FFI bindings