opencl_ruby_ffi 1.2.2 → 1.3.0

data/lib/opencl_ruby_ffi/khr/icd.rb

@@ -0,0 +1,30 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  PLATFORM_NOT_FOUND_KHR = -1001
+
+  PLATFORM_ICD_SUFFIX_KHR = 0x0920
+
+  class Error
+
+    eval error_class_constructor( :PLATFORM_NOT_FOUND_KHR, :PlatformNotFoundKHR )
+
+  end
+
+  class Platform
+    ICD_SUFFIX_KHR = 0x0920
+
+    module KHRICD
+      extend InnerGenerator
+
+      get_info("Platform", :string, "icd_suffix_khr")
+
+    end
+
+    register_extension( :cl_khr_icd,  KHRICD, "extensions.include?(\"cl_khr_icd\")" )
+
+  end
+
+end

data/lib/opencl_ruby_ffi/khr/initalize_memory.rb

@@ -0,0 +1,19 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  CONTEXT_MEMORY_INITIALIZE_KHR = 0x200E
+
+  class Context
+
+    MEMORY_INITIALIZE_KHR = 0x200E
+
+    class Properties
+      MEMORY_INITIALIZE_KHR = 0x2030
+      @codes[0x2030] = 'MEMORY_INITIALIZE_KHR'
+    end
+
+  end
+ 
+end

data/lib/opencl_ruby_ffi/khr/priority_hints.rb

@@ -0,0 +1,48 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  QUEUE_PRIORITY_KHR = 0x1096
+  QUEUE_PRIORITY_HIGH_KHR = (1<<0)
+  QUEUE_PRIORITY_MED_KHR = (1<<1)
+  QUEUE_PRIORITY_LOW_KHR = (1<<2)
+
+  class CommandQueue
+
+    PRIORITY_KHR = 0x1096
+    PRIORITY_HIGH_KHR = (1 << 0)
+    PRIORITY_MED_KHR = (1 << 1)
+    PRIORITY_LOW_KHR = (1 << 2)
+
+    class PriorityKHR < Enum
+      HIGH_KHR = (1 << 0)
+      MED_KHR = (1 << 1)
+      LOW_KHR = (1 << 2)
+      @codes = {}
+      @codes[(1 << 0)] = 'HIGH_KHR'
+      @codes[(1 << 1)] = 'MED_KHR'
+      @codes[(1 << 2)] = 'LOW_KHR'
+    end
+
+  end
+
+  module InnerInterface
+    TYPE_CONVERTER[:cl_queue_priority_khr] = CommandQueue::PriorityKHR
+  end
+
+  class CommandQueue
+
+    module KHRPriorityHints
+
+      extend InnerGenerator
+
+      get_info("CommandQueue", :cl_queue_priority_khr, "priority_khr")
+
+    end
+
+    register_extension( :cl_khr_priority_hints, KHRPriorityHints, "device.platform.extensions.include?(\"cl_khr_priority_hints\")" )
+
+  end
+
+end

data/lib/opencl_ruby_ffi/khr/spir.rb

@@ -0,0 +1,45 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  DEVICE_SPIR_VERSIONS = 0x40E0
+  PROGRAM_BINARY_TYPE_INTERMEDIATE = 0x40E1
+
+  class Device
+    SPIR_VERSIONS = 0x40E0
+
+    module KHRSPIR
+
+      # Return an Array of String corresponding to the SPIR versions supported by the device
+      def spir_versions
+        spir_versions_size = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetDeviceInfo( self, SPIR_VERSIONS, 0, nil, spir_versions_size)
+        error_check(error)
+        vers = MemoryPointer::new( spir_versions_size.read_size_t )
+        error = OpenCL.clGetDeviceInfo( self, SPIR_VERSIONS, spir_versions_size.read_size_t, vers, nil)
+        error_check(error)
+        vers_string = vers.read_string
+        return vers_string.split(" ")
+      end
+
+      def spir_versions_number
+        vers_strings = spir_versions
+        return vers_strings.collect { |s| s.scan(/(\d+\.\d+)/).first.first.to_f }
+      end
+
+    end
+
+    register_extension( :cl_khr_spir,  KHRSPIR, "platform.extensions.include?(\"cl_khr_spir\") or extensions.include?(\"cl_khr_spir\")" )
+
+  end
+
+  class Program
+    BINARY_TYPE_INTERMEDIATE = 0x40E1
+    class BinaryType
+      INTERMEDIATE = 0x40E1
+      @codes[0x40E1] = 'INTERMEDIATE'
+    end
+  end
+
+end

data/lib/opencl_ruby_ffi/khr/sub_groups.rb

@@ -0,0 +1,49 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR = 0x2033
+  KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR = 0x2034
+
+  attach_extension_function( "clGetKernelSubGroupInfoKHR", :cl_int, [Kernel, Device, :size_t, :pointer, :size_t, :pointer, :pointer] )
+
+  class Kernel
+    MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR = 0x2033
+    SUB_GROUP_COUNT_FOR_NDRANGE_KHR = 0x2034
+
+    module KHRSubGroups
+
+      def max_sub_group_size_for_ndrange_khr(local_work_size, device = program.devices.first)
+        error_check(INVALID_OPERATION) unless device.extensions.include?( "cl_khr_sub_groups" )
+        local_work_size = [local_work_size].flatten
+        lws_p = MemoryPointer::new( :size_t, local_work_size.length )
+        local_work_size.each_with_index { |e,i|
+          lws_p[i].write_size_t( e )
+        }
+        ptr = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetKernelSubGroupInfoKHR(self, device, MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR, lws_p.size, lws_p, ptr.size, ptr, nil)
+        error_check(error)
+        return ptr.read_size_t
+      end
+
+      def sub_groups_count_for_ndrange_khr(local_work_size, device = program.devices.first)
+        error_check(INVALID_OPERATION) unless device.extensions.include?( "cl_khr_sub_groups" )
+        local_work_size = [local_work_size].flatten
+        lws_p = MemoryPointer::new( :size_t, local_work_size.length )
+        local_work_size.each_with_index { |e,i|
+          lws_p[i].write_size_t( e )
+        }
+        ptr = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetKernelSubGroupInfoKHR(self, device, SUB_GROUP_COUNT_FOR_NDRANGE_KHR, lws_p.size, lws_p, ptr.size, ptr, nil)
+        error_check(error)
+        return ptr.read_size_t
+      end
+
+    end
+
+    register_extension( :cl_khr_sub_groups, KHRSubGroups, "program.devices.collect(&:extensions).flatten.include?(\"cl_khr_sub_groups\")" )
+
+  end
+
+end

data/lib/opencl_ruby_ffi/khr/terminate_context.rb

@@ -0,0 +1,46 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  DEVICE_TERMINATE_CAPABILITY_KHR = 0x2031
+  CONTEXT_TERMINATE_KHR = 0x2032
+
+  attach_extension_function("clTerminateContextKHR", :cl_int, [Context])
+
+  def self.terminate_context_khr( context )
+    error_check(INVALID_OPERATION) unless context.platform.extensions.include? "cl_khr_terminate_context"
+    error = clTerminateContextKHR( context )
+    error_check(error)
+  end
+
+  class Device
+
+    TERMINATE_CAPABILITY_KHR = 0x2031
+
+    get_info("Device", :cl_bitfield, "terminate_capability_khr")
+
+  end
+
+  class Context
+
+    TERMINATE_KHR = 0x2032
+
+    class Properties
+      TERMINATE_KHR = 0x2032
+      @codes[0x2032] = 'TERMINATE_KHR'
+    end
+
+    module KHRTerminateContext
+
+      def terminate_context_khr
+        return OpenCL.terminate_context_khr(self)
+      end
+
+    end
+
+    register_extension( :cl_khr_terminate_context, KHRTerminateContext, "platform.extensions.include?(\"cl_khr_terminate_context\")" )
+
+  end
+
+end

data/lib/opencl_ruby_ffi/khr/throttle_hints.rb

@@ -0,0 +1,47 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  QUEUE_THROTTLE_KHR = 0x1097
+  QUEUE_THROTTLE_HIGH_KHR = (1<<0)
+  QUEUE_THROTTLE_MED_KHR = (1<<1)
+  QUEUE_THROTTLE_LOW_KHR = (1<<2)
+
+  class CommandQueue
+
+    THROTTLE_KHR = 0x1097
+    THROTTLE_HIGH_KHR = (1 << 0)
+    THROTTLE_MED_KHR = (1 << 1)
+    THROTTLE_LOW_KHR = (1 << 2)
+
+    class ThrottleKHR < Enum
+      HIGH_KHR = (1 << 0)
+      MED_KHR = (1 << 1)
+      LOW_KHR = (1 << 2)
+      @codes = {}
+      @codes[(1 << 0)] = 'HIGH_KHR'
+      @codes[(1 << 1)] = 'MED_KHR'
+      @codes[(1 << 2)] = 'LOW_KHR'
+    end
+
+  end
+
+  module InnerInterface
+    TYPE_CONVERTER[:cl_queue_throttle_khr] = CommandQueue::ThrottleKHR
+  end
+
+  class CommandQueue
+
+    module KHRThrottleHints
+      extend InnerGenerator
+
+      get_info("CommandQueue", :cl_queue_throttle_khr, "throttle_khr")
+
+    end
+
+    register_extension( :cl_khr_throttle_hints, KHRThrottleHints, "device.platform.extensions.include?(\"cl_khr_throttle_hints\")" )
+
+  end
+
+end

data/lib/opencl_ruby_ffi/nv/device_attribute_query.rb

@@ -0,0 +1,50 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  DEVICE_COMPUTE_CAPABILITY_MAJOR_NV = 0x4000
+  DEVICE_COMPUTE_CAPABILITY_MINOR_NV = 0x4001
+  DEVICE_REGISTERS_PER_BLOCK_NV = 0x4002
+  DEVICE_WARP_SIZE_NV = 0x4003
+  DEVICE_GPU_OVERLAP_NV = 0x4004
+  DEVICE_KERNEL_EXEC_TIMEOUT_NV = 0x4005
+  DEVICE_INTEGRATED_MEMORY_NV = 0x4006
+  DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT_NV = 0x4007
+  DEVICE_PCI_BUS_ID_NV = 0x4008
+  DEVICE_PCI_SLOT_ID_NV = 0x4009
+
+  class Device
+
+    COMPUTE_CAPABILITY_MAJOR_NV = 0x4000
+    COMPUTE_CAPABILITY_MINOR_NV = 0x4001
+    REGISTERS_PER_BLOCK_NV = 0x4002
+    WARP_SIZE_NV = 0x4003
+    GPU_OVERLAP_NV = 0x4004
+    KERNEL_EXEC_TIMEOUT_NV = 0x4005
+    INTEGRATED_MEMORY_NV = 0x4006
+    ATTRIBUTE_ASYNC_ENGINE_COUNT_NV = 0x4007
+    PCI_BUS_ID_NV = 0x4008
+    PCI_SLOT_ID_NV = 0x4009
+
+    module NVDeviceAttributeQuery
+      extend InnerGenerator
+
+      get_info("Device", :cl_uint, "compute_capability_major_nv")
+      get_info("Device", :cl_uint, "compute_capability_minor_nv")
+      get_info("Device", :cl_uint, "registers_per_block_nv")
+      get_info("Device", :cl_uint, "warp_size_nv")
+      get_info("Device", :cl_uint, "attribute_async_engine_count_nv")
+      get_info("Device", :cl_uint, "pci_bus_id_nv")
+      get_info("Device", :cl_uint, "pci_slot_id_nv")
+      get_info("Device", :cl_bool, "gpu_overlap_nv")
+      get_info("Device", :cl_bool, "kernel_exec_timeout_nv")
+      get_info("Device", :cl_bool, "integrated_memory_nv")
+
+    end
+
+    register_extension( :cl_nv_device_attribute_query, NVDeviceAttributeQuery, "extensions.include?(\"cl_nv_device_attribute_query\")" )
+
+  end
+
+end

data/lib/opencl_ruby_ffi/opencl_ruby_ffi_base.rb

@@ -29,6 +29,12 @@ module OpenCL
 
   end
 
+  class Struct < FFI::Struct
+  end
+
+  class Union < FFI::Union
+  end
+
   @@callbacks = []
 
   # Maps the :cl_image_fomat type of OpenCL
@@ -120,7 +126,6 @@ module OpenCL
     end
   end
 
-  #:stopdoc:
   module InnerInterface
 
     private
@@ -241,8 +246,6 @@ module OpenCL
       :cl_device_local_mem_type => Device::LocalMemType,
       :cl_device_exec_capabilities => Device::ExecCapabilities,
       :cl_command_queue_properties => CommandQueue::Properties,
-      :cl_queue_priority_khr => CommandQueue::PriorityKHR,
-      :cl_queue_throttle_khr => CommandQueue::ThrottleKHR,
       :cl_device_affinity_domain => Device::AffinityDomain,
       :cl_device_svm_capabilities => Device::SVMCapabilities,
       :cl_channel_order => ChannelOrder,
@@ -285,17 +288,24 @@ module OpenCL
 
     private
 
-    #  Generates a new method for klass that use the apropriate clGetKlassInfo, to read an element of the given type. The info queried is specified by name.
+    # 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)
       klass_name = klass
       klass_name = "MemObject" if klass == "Mem"
       s = <<EOF
       def #{name.downcase}
         ptr1 = MemoryPointer::new( :size_t, 1)
-        error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name}, 0, nil, ptr1)
+        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}, ptr1.read_size_t, ptr2, nil)
+        error = OpenCL.clGet#{klass_name}Info(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})
@@ -304,30 +314,47 @@ module OpenCL
         end
       end
 EOF
-      return s
+      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.
+    # 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)
       klass_name = klass
       klass_name = "MemObject" if klass == "Mem"
       s = <<EOF
       def #{name.downcase}
         ptr1 = MemoryPointer::new( :size_t, 1)
-        error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name}, 0, nil, ptr1)
+        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}, ptr1.read_size_t, ptr2, nil)
+        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)
-        return arr
+        if(convert_type(:#{type})) then
+          return arr.collect { |e| convert_type(:#{type})::new(e) }
+        else
+          return arr
+        end
       end
 EOF
-      return s
+      module_eval s
     end
 
   end
   private_constant :InnerGenerator
-  #:startdoc:
 
 end