opencl_ruby_ffi 1.3.6 → 1.3.7

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/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
@@ -287,7 +287,7 @@ module OpenCL
   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.
+    # Generates a new method for klass that use the given clGetKlassInfo extension of the object's 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
@@ -295,18 +295,38 @@ module OpenCL
     #   @!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"
+    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_name}, :cl_uint, :size_t, :pointer, :pointer])
+        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)
+        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 )
+        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
@@ -316,6 +336,7 @@ module OpenCL
         end
       end
 EOF
+      end
       if type == :cl_bool then
         s += <<EOF
       def #{name.downcase}?
@@ -326,7 +347,7 @@ 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.
+    # Generates a new method for klass that use the given clGetKlassInfo extension of the object's platform, 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
@@ -334,21 +355,42 @@ EOF
     #   @!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"
+    def get_info_array_ext(klass, type, name, function, memoizable = false)
+      if memoizable
       s = <<EOF
       def #{name.downcase}
-        f = platform.get_extension_function("#{function}", :cl_int, [:cl_uint, :size_t, :pointer, :pointer])
+        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)
+        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 )
+        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)
+        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
@@ -356,6 +398,7 @@ EOF
         end
       end
 EOF
+      end
       module_eval s
     end
 
@@ -374,15 +417,34 @@ EOF
     #   @!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
@@ -392,6 +454,7 @@ EOF
         end
       end
 EOF
+      end
       if type == :cl_bool then
         s += <<EOF
       def #{name.downcase}?
@@ -406,22 +469,43 @@ EOF
     # @param [String] klass the property is to be found
     # @param [Symbol] type of the property
     # @param [String] name of the property
+    # @param [Bool] 
     # @!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
@@ -429,6 +513,7 @@ EOF
         end
       end
 EOF
+      end
       module_eval s
     end
 

data/opencl_ruby_ffi.gemspec

@@ -1,13 +1,12 @@
 Gem::Specification.new do |s|
   s.name = 'opencl_ruby_ffi'
-  s.version = "1.3.6"
+  s.version = "1.3.7"
   s.author = "Brice Videau"
   s.email = "bvideau@anl.gov"
   s.homepage = "https://github.com/Nanosim-LIG/opencl-ruby"
   s.summary = "Ruby OpenCL FFI bindings"
   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'
   s.add_dependency 'narray', '~> 0.6', '>=0.6.0.8'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opencl_ruby_ffi
 version: !ruby/object:Gem::Version
-  version: 1.3.6
+  version: 1.3.7
 platform: ruby
 authors:
 - Brice Videau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-18 00:00:00.000000000 Z
+date: 2020-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -100,7 +100,10 @@ files:
 - 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/kernel_profiling.rb
 - lib/opencl_ruby_ffi/intel/motion_estimation.rb
+- lib/opencl_ruby_ffi/intel/unified_shared_memory_preview.rb
+- lib/opencl_ruby_ffi/intel/unofficial.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
@@ -143,8 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Ruby OpenCL FFI bindings