opencl_ruby_ffi 1.3.3 → 1.3.8

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
@@ -126,6 +126,76 @@ module OpenCL
     end
   end
 
+  class Version
+    include Comparable
+    MAJOR_BITS = 10
+    MINOR_BITS = 10
+    PATCH_BITS = 12
+    MAJOR_MASK = (1 << MAJOR_BITS) - 1
+    MINOR_MASK = (1 << MINOR_BITS) - 1
+    PATCH_MASK = (1 << PATCH_BITS) - 1
+
+    attr_reader :major, :minor, :patch
+    def initialize(major, minor = 0, patch = 0)
+      @major = major
+      @minor = minor
+      @patch = patch
+    end
+
+    def to_int
+      Version.make(@major, @minor, @patch)
+    end
+    alias to_i to_int
+
+    def <=>(other)
+      res = (@major <=> other.major)
+      res = (@minor <=> other.minor) if res == 0
+      res = (@patch <=> other.patch) if res == 0
+      res
+    end
+
+    def to_s
+      "#{@major}.#{@minor}.#{@patch}"
+    end
+
+    def self.major(v)
+      v >> (MINOR_BITS + PATCH_BITS)
+    end
+
+    def self.minor(v)
+      (v >> (PATCH_BITS)) & MINOR_MASK
+    end
+
+    def self.patch(v)
+      v & PATCH_MASK
+    end
+
+    def self.make(major, minor = 0, patch = 0)
+      ((major & MAJOR_MASK) << (MINOR_BITS + PATCH_BITS)) +
+      ((minor & MINOR_MASK) << PATCH_BITS) +
+       (patch & PATCH_MASK)
+    end
+
+    def self.from_int(v)
+      self.new(major(v), minor(v), patch(v))
+    end
+  end
+
+  # Maps the :cl_name_version type of OpenCL
+  class NameVersion < Struct
+    MAX_NAME_SIZE = 64
+    layout :version, :cl_version,
+           :name, [:char, MAX_NAME_SIZE]
+
+    def version
+      Version.from_int(self[:version])
+    end
+
+    def name
+      self[:name].to_s
+    end
+  end
+
   module InnerInterface
 
     private
@@ -169,7 +239,7 @@ module OpenCL
       end
       return properties
     end
-  
+
     # Extracts the origin_symbol and region_symbol named options for image from the given hash. Returns the read (or detemined suitable) origin and region in a tuple
     def get_origin_region( image, options, origin_symbol, region_symbol )
       origin = MemoryPointer::new( :size_t, 3 )
@@ -214,6 +284,19 @@ module OpenCL
       return properties
     end
   
+    # EXtracts the :properties named option (for a Mem) from the hash given and returns the properties values
+    def get_mem_properties( options )
+      properties = nil
+      if options[:properties] then
+        properties = MemoryPointer::new( :cl_mem_properties, options[:properties].length + 1 )
+        options[:properties].each_with_index { |e,i|
+          properties[i].write_cl_mem_properties(e.respond_to?(:to_ptr) ? e : e.to_i)
+        }
+        properties[options[:properties].length].write_cl_mem_properties(0)
+      end
+      return properties
+    end
+  
     # Extracts the :device_list named option from the hash given and returns [ number of devices, an Pointer to the list of Device or nil ]
     def get_device_list( options )
       devices = options[:device_list]
@@ -248,6 +331,7 @@ module OpenCL
       :cl_command_queue_properties => CommandQueue::Properties,
       :cl_device_affinity_domain => Device::AffinityDomain,
       :cl_device_svm_capabilities => Device::SVMCapabilities,
+      :cl_device_atomic_capabilities => Device::AtomicCapabilities,
       :cl_channel_order => ChannelOrder,
       :cl_channel_type => ChannelType,
       :cl_mem_flags => Mem::Flags,
@@ -284,27 +368,156 @@ module OpenCL
     include InnerInterface
   end
 
+  module ExtensionInnerGenerator
+
+    private
+
+    # @!macro [attach] get_info_ext
+    #   @!method $3
+    #   Returns the OpenCL::$1::$3 info
+    #   @return $2
+    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}, :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
+      end
+      if type == :cl_bool then
+        s += <<EOF
+      def #{name.downcase}?
+        #{name.downcase} == 0 ? false : true
+      end
+EOF
+      end
+      module_eval s
+    end
+
+    # @!macro [attach] get_info_array_ext
+    #   @!method $3
+    #   Returns the OpenCL::$1::$3 info
+    #   @return an Array of $2
+    def get_info_array_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)
+        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
+          return arr
+        end
+      end
+EOF
+      end
+      module_eval s
+    end
+
+  end
+  private_constant :ExtensionInnerGenerator
+
   module InnerGenerator
 
     private
 
-    # 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)
+    def get_info(klass, type, name, memoizable = false)
       klass_name = klass
       klass_name = "MemObject" if klass == "Mem"
+      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)
+        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)
+        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
@@ -314,6 +527,7 @@ module OpenCL
         end
       end
 EOF
+      end
       if type == :cl_bool then
         s += <<EOF
       def #{name.downcase}?
@@ -324,26 +538,42 @@ 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.
-    # @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)
+    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}
+        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)
+        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)
+        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
           return arr.collect { |e| convert_type(:#{type})::new(e) }
         else
@@ -351,6 +581,7 @@ EOF
         end
       end
 EOF
+      end
       module_eval s
     end
 

data/lib/opencl_ruby_ffi/opencl_ruby_ffi_base_gen.rb

@@ -2,7 +2,11 @@ using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
 # Maps the OpenCL API using FFI
 module OpenCL
   begin
-    ffi_lib ENV["LIBOPENCL_SO"]
+    if ENV["LIBOPENCL_SO"]
+      ffi_lib ENV["LIBOPENCL_SO"]
+    else
+      raise LoadError
+    end
   rescue LoadError => e
     begin
       ffi_lib "OpenCL"
@@ -79,12 +83,15 @@ module OpenCL
   INVALID_DEVICE_PARTITION_COUNT = -68
   INVALID_PIPE_SIZE = -69
   INVALID_DEVICE_QUEUE = -70
+  INVALID_SPEC_ID = -71
+  MAX_SIZE_RESTRICTION_EXCEEDED = -72
   INVALID_PARTITION_NAME_EXT = -1059
   VERSION_1_0 = 1
   VERSION_1_1 = 1
   VERSION_1_2 = 1
   VERSION_2_0 = 1
   VERSION_2_1 = 1
+  VERSION_2_2 = 1
   FALSE = 0
   TRUE = 1
   BLOCKING = TRUE
@@ -95,6 +102,8 @@ module OpenCL
   PLATFORM_VENDOR = 0x0903
   PLATFORM_EXTENSIONS = 0x0904
   PLATFORM_HOST_TIMER_RESOLUTION = 0x0905
+  PLATFORM_NUMERIC_VERSION = 0x0906
+  PLATFORM_EXTENSIONS_WITH_VERSION = 0x0907
   DEVICE_TYPE_DEFAULT = (1 << 0)
   DEVICE_TYPE_CPU = (1 << 1)
   DEVICE_TYPE_GPU = (1 << 2)
@@ -194,6 +203,20 @@ module OpenCL
   DEVICE_IL_VERSION = 0x105B
   DEVICE_MAX_NUM_SUB_GROUPS = 0x105C
   DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS = 0x105D
+  DEVICE_NUMERIC_VERSION = 0x105E
+  DEVICE_EXTENSIONS_WITH_VERSION = 0x1060
+  DEVICE_ILS_WITH_VERSION = 0x1061
+  DEVICE_BUILT_IN_KERNELS_WITH_VERSION = 0x1062
+  DEVICE_ATOMIC_MEMORY_CAPABILITIES = 0x1063
+  DEVICE_ATOMIC_FENCE_CAPABILITIES = 0x1064
+  DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT = 0x1065
+  DEVICE_OPENCL_C_ALL_VERSIONS = 0x1066
+  DEVICE_PREFERRED_WORK_GROUP_SIZE_MULTIPLE = 0x1067
+  DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT = 0x1068
+  DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT = 0x1069
+  DEVICE_OPENCL_C_FEATURES = 0x106F
+  DEVICE_DEVICE_ENQUEUE_SUPPORT = 0x1070
+  DEVICE_PIPE_SUPPORT = 0x1071
   FP_DENORM = (1 << 0)
   FP_INF_NAN = (1 << 1)
   FP_ROUND_TO_NEAREST = (1 << 2)
@@ -233,12 +256,20 @@ module OpenCL
   DEVICE_SVM_FINE_GRAIN_BUFFER = (1 << 1)
   DEVICE_SVM_FINE_GRAIN_SYSTEM = (1 << 2)
   DEVICE_SVM_ATOMICS = (1 << 3)
+  DEVICE_ATOMIC_ORDER_RELAXED = (1 << 0)
+  DEVICE_ATOMIC_ORDER_ACQ_REL = (1 << 1)
+  DEVICE_ATOMIC_ORDER_SEQ_CST = (1 << 2)
+  DEVICE_ATOMIC_SCOPE_WORK_ITEM = (1 << 3)
+  DEVICE_ATOMIC_SCOPE_WORK_GROUP = (1 << 4)
+  DEVICE_ATOMIC_SCOPE_DEVICE = (1 << 5)
+  DEVICE_ATOMIC_SCOPE_ALL_DEVICES = (1 << 6)
   QUEUE_CONTEXT = 0x1090
   QUEUE_DEVICE = 0x1091
   QUEUE_REFERENCE_COUNT = 0x1092
   QUEUE_PROPERTIES = 0x1093
   QUEUE_SIZE = 0x1094
   QUEUE_DEVICE_DEFAULT = 0x1095
+  QUEUE_PROPERTIES_ARRAY = 0x1098
   MEM_READ_WRITE = (1 << 0)
   MEM_WRITE_ONLY = (1 << 1)
   MEM_READ_ONLY = (1 << 2)
@@ -316,6 +347,7 @@ module OpenCL
   MEM_ASSOCIATED_MEMOBJECT = 0x1107
   MEM_OFFSET = 0x1108
   MEM_USES_SVM_POINTER = 0x1109
+  MEM_PROPERTIES = 0x110A
   IMAGE_FORMAT = 0x1110
   IMAGE_ELEMENT_SIZE = 0x1111
   IMAGE_ROW_PITCH = 0x1112
@@ -329,6 +361,7 @@ module OpenCL
   IMAGE_NUM_SAMPLES = 0x111A
   PIPE_PACKET_SIZE = 0x1120
   PIPE_MAX_PACKETS = 0x1121
+  PIPE_PROPERTIES = 0x1122
   ADDRESS_NONE = 0x1130
   ADDRESS_CLAMP_TO_EDGE = 0x1131
   ADDRESS_CLAMP = 0x1132
@@ -357,6 +390,8 @@ module OpenCL
   PROGRAM_NUM_KERNELS = 0x1167
   PROGRAM_KERNEL_NAMES = 0x1168
   PROGRAM_IL = 0x1169
+  PROGRAM_SCOPE_GLOBAL_CTORS_PRESENT = 0x116A
+  PROGRAM_SCOPE_GLOBAL_DTORS_PRESENT = 0x116B
   PROGRAM_BUILD_STATUS = 0x1181
   PROGRAM_BUILD_OPTIONS = 0x1182
   PROGRAM_BUILD_LOG = 0x1183
@@ -442,6 +477,7 @@ module OpenCL
   COMMAND_SVM_MEMFILL = 0x120B
   COMMAND_SVM_MAP = 0x120C
   COMMAND_SVM_UNMAP = 0x120D
+  COMMAND_SVM_MIGRATE_MEM = 0x120E
   COMPLETE = 0x0
   RUNNING = 0x1
   SUBMITTED = 0x2
@@ -473,6 +509,13 @@ module OpenCL
   MEM_HOST_WRITETHROUGH_QCOM = 0x40A6
   MEM_HOST_WRITE_COMBINING_QCOM = 0x40A7
   MEM_ION_HOST_PTR_QCOM = 0x40A8
+  NAME_VERSION_MAX_NAME_SIZE = 64
+  VERSION_MAJOR_BITS = 10
+  VERSION_MINOR_BITS = 10
+  VERSION_PATCH_BITS = 12
+  VERSION_MAJOR_MASK = (1 << VERSION_MAJOR_BITS) - 1
+  VERSION_MINOR_MASK = (1 << VERSION_MINOR_BITS) - 1
+  VERSION_PATCH_MASK = (1 << VERSION_PATCH_BITS) - 1
   # Parent class to map OpenCL errors, and is used to raise unknown errors
   class Error < StandardError
     attr_reader :code
@@ -593,6 +636,8 @@ EOF
       [:INVALID_DEVICE_PARTITION_COUNT,            :InvalidDevicePartitionCount],
       [:INVALID_PIPE_SIZE,                         :InvalidPipeSize],
       [:INVALID_DEVICE_QUEUE,                      :InvalidDeviceQueue],
+      [:INVALID_SPEC_ID,                           :InvalidSpecID],
+      [:MAX_SIZE_RESTRICTION_EXCEEDED,             :MaxSizeRestrictionExceeded],
       [:INVALID_PARTITION_NAME_EXT,                :InvalidPartitionNameEXT]
     ].each { |name, capitalized_name|
       eval error_class_constructor( name, capitalized_name )
@@ -684,8 +729,7 @@ EOF
 
     # Returns true if flag is bitwise included in the Bitfield
     def include?(flag)
-      return true if ( @val & flag ) == flag
-      return false
+      return ( @val & flag ) == flag
     end
 
     # Returns a String corresponding to the Bitfield description
@@ -733,7 +777,7 @@ EOF
       return @val
     end
 
-    # Setss the internal representation of the Bitfield to val
+    # Sets the internal representation of the Bitfield to val
     def flags=(val)
       @val = val
     end
@@ -751,7 +795,7 @@ EOF
       #   @!parse include $2
       #   @private
       def self.register_extension(name, mod, cond)
-        self.send(:include, mod)
+        self.send(:prepend, mod)
       end
 
     else
@@ -788,6 +832,8 @@ EOF
     VENDOR = 0x0903
     EXTENSIONS = 0x0904
     HOST_TIMER_RESOLUTION = 0x0905
+    NUMERIC_VERSION = 0x0906
+    EXTENSIONS_WITH_VERSION = 0x0907
   
     # Creates a new Platform and retains it if specified and aplicable
     def initialize(ptr, retain = true)
@@ -903,6 +949,20 @@ EOF
     IL_VERSION = 0x105B
     MAX_NUM_SUB_GROUPS = 0x105C
     SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS = 0x105D
+    NUMERIC_VERSION = 0x105E
+    EXTENSIONS_WITH_VERSION = 0x1060
+    ILS_WITH_VERSION = 0x1061
+    BUILT_IN_KERNELS_WITH_VERSION = 0x1062
+    ATOMIC_MEMORY_CAPABILITIES = 0x1063
+    ATOMIC_FENCE_CAPABILITIES = 0x1064
+    NON_UNIFORM_WORK_GROUP_SUPPORT = 0x1065
+    OPENCL_C_ALL_VERSIONS = 0x1066
+    PREFERRED_WORK_GROUP_SIZE_MULTIPLE = 0x1067
+    WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT = 0x1068
+    GENERIC_ADDRESS_SPACE_SUPPORT = 0x1069
+    OPENCL_C_FEATURES = 0x106F
+    DEVICE_ENQUEUE_SUPPORT = 0x1070
+    PIPE_SUPPORT = 0x1071
     PARTITION_EQUALLY = 0x1086
     PARTITION_BY_COUNTS = 0x1087
     PARTITION_BY_COUNTS_LIST_END = 0x0
@@ -918,6 +978,13 @@ EOF
     SVM_FINE_GRAIN_SYSTEM = (1 << 2)
     SVM_ATOMICS = (1 << 3)
     PAGE_SIZE_QCOM = 0x40A1
+    ATOMIC_ORDER_RELAXED = (1 << 0)
+    ATOMIC_ORDER_ACQ_REL = (1 << 1)
+    ATOMIC_ORDER_SEQ_CST = (1 << 2)
+    ATOMIC_SCOPE_WORK_ITEM = (1 << 3)
+    ATOMIC_SCOPE_WORK_GROUP = (1 << 4)
+    ATOMIC_SCOPE_DEVICE = (1 << 5)
+    ATOMIC_SCOPE_ALL_DEVICES = (1 << 6)
 
     #DEFINED in ext/device_fission.rb  
 #    # Creates a new Device and retains it if specified and aplicable
@@ -1068,6 +1135,25 @@ EOF
       end
     end
 
+    # Bitfield that maps the :cl_device_atomic_capabilities
+    class AtomicCapabilities < Bitfield
+      ORDER_RELAXED = (1 << 0)
+      ORDER_ACQ_REL = (1 << 1)
+      ORDER_SEQ_CST = (1 << 2)
+      SCOPE_WORK_ITEM = (1 << 3)
+      SCOPE_WORK_GROUP = (1 << 4)
+      SCOPE_DEVICE = (1 << 5)
+      SCOPE_ALL_DEVICES = (1 << 6)
+      # Returns an Array of String representing the different flags set
+      def names
+        fs = []
+        %w( ORDER_RELAXED ORDER_ACQ_REL ORDER_SEQ_CST SCOPE_WORK_ITEM SCOPE_WORK_GROUP SCOPE_DEVICE SCOPE_ALL_DEVICES ).each { |f|
+          fs.push(f) if self.include?( self.class.const_get(f) )
+        }
+        return fs
+      end
+    end
+
   end
   class Context < ExtendedStruct
     layout :dummy, :pointer
@@ -1121,6 +1207,7 @@ EOF
     PROPERTIES = 0x1093
     SIZE = 0x1094
     DEVICE_DEFAULT = 0x1095
+    PROPERTIES_ARRAY = 0x1098
     # Creates a new CommandQueue and retains it if specified and aplicable
     def initialize(ptr, retain = true)
       super(ptr)
@@ -1191,6 +1278,7 @@ EOF
     ASSOCIATED_MEMOBJECT = 0x1107
     OFFSET = 0x1108
     USES_SVM_POINTER = 0x1109
+    PROPERTIES = 0x110A
     HOST_UNCACHED_QCOM = 0x40A4
     HOST_WRITEBACK_QCOM = 0x40A5
     HOST_WRITETHROUGH_QCOM = 0x40A6
@@ -1308,6 +1396,8 @@ EOF
     NUM_KERNELS = 0x1167
     KERNEL_NAMES = 0x1168
     IL = 0x1169
+    SCOPE_GLOBAL_CTORS_PRESENT = 0x116A
+    SCOPE_GLOBAL_DTORS_PRESENT = 0x116B
     BUILD_STATUS = 0x1181
     BUILD_OPTIONS = 0x1182
     BUILD_LOG = 0x1183
@@ -1724,6 +1814,7 @@ EOF
     SVM_MEMFILL = 0x120B
     SVM_MAP = 0x120C
     SVM_UNMAP = 0x120D
+    SVM_MIGRATE_MEM = 0x120E
     @codes = {}
     @codes[0x11F0] = 'NDRANGE_KERNEL'
     @codes[0x11F1] = 'TASK'
@@ -1755,6 +1846,7 @@ EOF
     @codes[0x120B] = 'SVM_MEMFILL'
     @codes[0x120C] = 'SVM_MAP'
     @codes[0x120D] = 'SVM_UNMAP'
+    @codes[0x120E] = 'SVM_MIGRATE_MEM'
   end
 
   # Enum that maps the :cl_gl_object_type type
@@ -1826,14 +1918,15 @@ EOF
     layout :dummy, :pointer
     PACKET_SIZE = 0x1120
     MAX_PACKETS = 0x1121
+    PROPERTIES = 0x1122
   end
   attach_function :clGetPlatformIDs, [:cl_uint,:pointer,:pointer], :cl_int
   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
@@ -1957,6 +2050,21 @@ EOF
           attach_function :clCloneKernel, [Kernel,:pointer], Kernel
           attach_function :clGetKernelSubGroupInfo, [Kernel,Device,:cl_kernel_sub_group_info,:size_t,:pointer,:size_t,:pointer,:pointer], :cl_int
           attach_function :clEnqueueSVMMigrateMem, [CommandQueue,:cl_uint,:pointer,:pointer,:cl_mem_migration_flags,:cl_uint,:pointer,:pointer], :cl_int
+          begin # OpenCL 2.2
+            callback :clSetProgramReleaseCallback_notify, [Program.by_ref,:pointer], :void
+            attach_function :clSetProgramReleaseCallback, [Program,:clSetProgramReleaseCallback_notify,:pointer], :cl_int
+            attach_function :clSetProgramSpecializationConstant, [Program,:cl_uint,:size_t,:pointer], :cl_int
+            begin # OpenCL 3.0
+              attach_function :clCreateBufferWithProperties, [Context,:pointer,:cl_mem_flags,:size_t,:pointer,:pointer], Mem
+              attach_function :clCreateImageWithProperties, [Context,:pointer,:cl_mem_flags,:pointer,:pointer,:pointer,:pointer], Mem
+              callback :clSetContextDestructorCallback_notify, [Context.by_ref,:pointer], :void
+              attach_function :clSetContextDestructorCallback, [Context,:clSetContextDestructorCallback_notify,:pointer], :cl_int
+            rescue NotFoundError => e
+              warn "Warning OpenCL 2.2 loader detected!"
+            end
+          rescue NotFoundError => e
+            warn "Warning OpenCL 2.1 loader detected!"
+          end
         rescue NotFoundError => e
           warn "Warning OpenCL 2.0 loader detected!"
         end