opencl_ruby_ffi 1.2.2 → 1.3.0

data/lib/opencl_ruby_ffi/Sampler.rb

@@ -60,13 +60,10 @@ module OpenCL
     Sampler::new(sampler_ptr, false)
   end
 
-  # Maps the cl_smapler object of OpenCL
+  # Maps the cl_sampler object of OpenCL
   class Sampler
     include InnerInterface
-
-    class << self
-      include InnerGenerator
-    end
+    extend InnerGenerator
 
     def inspect
       return "#<#{self.class.name}: #{addressing_mode} #{filter_mode} normalized: #{normalized_coords}>"
@@ -80,25 +77,10 @@ module OpenCL
       return Context::new( ptr.read_pointer )
     end
 
-    ##
-    # :method: reference_count()
-    # returns the reference counter of the Sampler
-    eval get_info("Sampler", :cl_uint, "REFERENCE_COUNT")
-
-    ##
-    # :method: normalized_coords()
-    # returns if the Sampler uses normalized coords
-    eval get_info("Sampler", :cl_bool, "NORMALIZED_COORDS")
-
-    ##
-    # :method: addressing_mode()
-    # returns an AddressingMode representing the addressing mode used by the Sampler
-    eval get_info("Sampler", :cl_addressing_mode, "ADDRESSING_MODE")
-
-    ##
-    # :method: filter_mode()
-    # returns a FilterMode representing the filtering mode used by the Sampler
-    eval get_info("Sampler", :cl_filter_mode, "FILTER_MODE")
+    get_info("Sampler", :cl_uint, "reference_count")
+    get_info("Sampler", :cl_bool, "normalized_coords")
+    get_info("Sampler", :cl_addressing_mode, "addressing_mode")
+    get_info("Sampler", :cl_filter_mode, "filter_mode")
 
   end
 

data/lib/opencl_ruby_ffi/amd/device_attribute_query.rb

@@ -0,0 +1,100 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  DEVICE_TOPOLOGY_TYPE_PCIE_AMD = 1
+  DEVICE_PROFILING_TIMER_OFFSET_AMD = 0x4036
+  DEVICE_TOPOLOGY_AMD = 0x4037
+  DEVICE_BOARD_NAME_AMD = 0x4038
+  DEVICE_GLOBAL_FREE_MEMORY_AMD = 0x4039
+  DEVICE_SIMD_PER_COMPUTE_UNIT_AMD = 0x4040
+  DEVICE_SIMD_WIDTH_AMD = 0x4041
+  DEVICE_SIMD_INSTRUCTION_WIDTH_AMD = 0x4042
+  DEVICE_WAVEFRONT_WIDTH_AMD = 0x4043
+  DEVICE_GLOBAL_MEM_CHANNELS_AMD = 0x4044
+  DEVICE_GLOBAL_MEM_CHANNEL_BANKS_AMD = 0x4045
+  DEVICE_GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD = 0x4046
+  DEVICE_LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD = 0x4047
+  DEVICE_LOCAL_MEM_BANKS_AMD = 0x4048
+  DEVICE_THREAD_TRACE_SUPPORTED_AMD = 0x4049
+  DEVICE_GFXIP_MAJOR_AMD = 0x404A
+  DEVICE_GFXIP_MINOR_AMD = 0x404B
+  DEVICE_AVAILABLE_ASYNC_QUEUES_AMD = 0x404C
+
+  class Device
+
+    TOPOLOGY_TYPE_PCIE_AMD = 1
+    PROFILING_TIMER_OFFSET_AMD = 0x4036
+    TOPOLOGY_AMD = 0x4037
+    BOARD_NAME_AMD = 0x4038
+    GLOBAL_FREE_MEMORY_AMD = 0x4039
+    SIMD_PER_COMPUTE_UNIT_AMD = 0x4040
+    SIMD_WIDTH_AMD = 0x4041
+    SIMD_INSTRUCTION_WIDTH_AMD = 0x4042
+    WAVEFRONT_WIDTH_AMD = 0x4043
+    GLOBAL_MEM_CHANNELS_AMD = 0x4044
+    GLOBAL_MEM_CHANNEL_BANKS_AMD = 0x4045
+    GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD = 0x4046
+    LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD = 0x4047
+    LOCAL_MEM_BANKS_AMD = 0x4048
+    THREAD_TRACE_SUPPORTED_AMD = 0x4049
+    GFXIP_MAJOR_AMD = 0x404A
+    GFXIP_MINOR_AMD = 0x404B
+    AVAILABLE_ASYNC_QUEUES_AMD = 0x404C
+
+    module AMDDeviceAttributeQuery
+      extend InnerGenerator
+
+      class AMDTopology < Union
+        class Raw < Struct
+          layout :type,  UInt,
+                 :data, [UInt, 5]
+        end
+        class PCIE < Struct
+          layout :type,     UInt,
+                 :unused,  [Char, 17],
+                 :bus,      Char,
+                 :device,   Char,
+                 :function, Char
+        end
+        layout :raw, Raw,
+               :pcie, PCIE
+      end
+
+      get_info("Device", :string, "board_name_amd")
+
+      get_info("Device", :cl_ulong, "profiling_timer_offset_amd")
+
+      get_info("Device", :cl_uint, "simd_per_compute_unit_amd")
+      get_info("Device", :cl_uint, "simd_width_amd")
+      get_info("Device", :cl_uint, "simd_instruction_width_amd")
+      get_info("Device", :cl_uint, "wavefront_width_amd")
+      get_info("Device", :cl_uint, "global_mem_channels_amd")
+      get_info("Device", :cl_uint, "global_mem_channel_banks_amd")
+      get_info("Device", :cl_uint, "global_mem_channel_bank_width_amd")
+      get_info("Device", :cl_uint, "local_mem_banks_amd")
+      get_info("Device", :cl_uint, "gfxip_major_amd")
+      get_info("Device", :cl_uint, "gfxip_minor_amd")
+      get_info("Device", :cl_uint, "available_async_queues_amd")
+
+      get_info("Device", :cl_bool, "thread_trace_supported_amd")
+
+      get_info("Device", :size_t, "local_mem_size_per_compute_unit_amd")
+
+      get_info_array("Device", :size_t, "global_free_memory_amd")
+
+      def topology_amd
+        ptr1 = MemoryPointer::new( AMDTopology )
+        error = OpenCL.clGetDeviceInfo(self, TOPOLOGY_AMD, ptr1.size, ptr1, nil)
+        error_check(error)
+        return AMDTopology::new(ptr1)
+      end
+
+    end
+
+    register_extension( :cl_amd_device_attribute_query,  AMDDeviceAttributeQuery, "extensions.include?(\"cl_amd_device_attribute_query\")" )
+
+  end
+
+end

data/lib/opencl_ruby_ffi/egl.rb

@@ -0,0 +1,2 @@
+require "opencl_ruby_ffi/khr/egl_image.rb"
+require "opencl_ruby_ffi/khr/egl_event.rb"

data/lib/opencl_ruby_ffi/ext.rb

@@ -0,0 +1,11 @@
+require "opencl_ruby_ffi/khr/fp64.rb"
+require "opencl_ruby_ffi/khr/fp16.rb"
+require "opencl_ruby_ffi/khr/icd.rb"
+require "opencl_ruby_ffi/khr/initalize_memory.rb"
+require "opencl_ruby_ffi/khr/spir.rb"
+require "opencl_ruby_ffi/nv/device_attribute_query.rb"
+require "opencl_ruby_ffi/amd/device_attribute_query.rb"
+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"

data/lib/opencl_ruby_ffi/ext/device_fission.rb

@@ -0,0 +1,264 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  DEVICE_PARTITION_FAILED_EXT = -1057
+  INVALID_PARTITION_COUNT_EXT = -1058
+
+  DEVICE_PARTITION_EQUALLY_EXT = 0x4050
+  DEVICE_PARTITION_BY_COUNTS_EXT = 0x4051
+  DEVICE_PARTITION_BY_NAMES_EXT = 0x4052
+  DEVICE_PARTITION_BY_AFFINITY_DOMAIN_EXT = 0x4053
+
+  DEVICE_PARENT_DEVICE_EXT = 0x4054
+  DEVICE_PARTITION_TYPES_EXT = 0x4055
+  DEVICE_AFFINITY_DOMAINS_EXT = 0x4056
+  DEVICE_REFERENCE_COUNT_EXT = 0x4057
+  DEVICE_PARTITION_STYLE_EXT = 0x4058
+
+  AFFINITY_DOMAIN_L1_CACHE_EXT = 0x1
+  AFFINITY_DOMAIN_L2_CACHE_EXT = 0x2
+  AFFINITY_DOMAIN_L3_CACHE_EXT = 0x3
+  AFFINITY_DOMAIN_L4_CACHE_EXT = 0x4
+  AFFINITY_DOMAIN_NUMA_EXT = 0x10
+  AFFINITY_DOMAIN_NEXT_FISSIONABLE_EXT = 0x100
+
+  PROPERTIES_LIST_END_EXT = 0
+  PARTITION_BY_COUNTS_LIST_END_EXT = 0
+  PARTITION_BY_NAMES_LIST_END_EXT = -1
+
+  [
+    [ "clReleaseDeviceEXT",
+      :cl_int,
+      [ Device ]
+    ], [
+      "clRetainDeviceEXT",
+      :cl_int,
+      [ Device ]
+    ], [
+      "clCreateSubDevicesEXT",
+      :cl_int,
+      [ Device,
+        :pointer,
+        :cl_uint,
+        :pointer,
+        :pointer ]
+    ]
+  ].each { |name, return_type, args|
+    attach_extension_function(name, return_type, args)
+  }
+
+  def self.create_sub_devices_ext( in_device, properties )
+    error_check(INVALID_OPERATION) if in_device.platform.version_number < 1.1 and not in_device.platform.extensions.include? "cl_ext_device_fission"
+    props = MemoryPointer::new( :cl_device_partition_property_ext, properties.length + 1 )
+    properties.each_with_index { |e,i|
+      props[i].write_cl_device_partition_property_ext(e)
+    }
+    props[properties.length].write_cl_device_partition_property_ext(0)
+    device_number_ptr = MemoryPointer::new( :cl_uint )
+    error = clCreateSubDevicesEXT( in_device, props, 0, nil, device_number_ptr )
+    error_check(error)
+    device_number = device_number_ptr.read_cl_uint
+    devices_ptr = MemoryPointer::new( Device, device_number )
+    error = clCreateSubDevicesEXT( in_device, props, device_number, devices_ptr, nil )
+    error_check(error)
+    devices_ptr.get_array_of_pointer(0, device_number).collect { |device_ptr|
+      Device::new(device_ptr, false)
+    }
+  end
+
+  class Error
+
+    eval error_class_constructor( :INVALID_PARTITION_COUNT_EXT, :InvalidPartitionCountEXT )
+    eval error_class_constructor( :DEVICE_PARTITION_FAILED_EXT, :DevicePartitionFailedEXT )
+
+  end
+
+  class Device
+
+    PARTITION_EQUALLY_EXT = 0x4050
+    PARTITION_BY_COUNTS_EXT = 0x4051
+    PARTITION_BY_NAMES_EXT = 0x4052
+    PARTITION_BY_AFFINITY_DOMAIN_EXT = 0x4053
+
+    PARENT_DEVICE_EXT = 0x4054
+    PARTITION_TYPES_EXT = 0x4055
+    AFFINITY_DOMAINS_EXT = 0x4056
+    REFERENCE_COUNT_EXT = 0x4057
+    PARTITION_STYLE_EXT = 0x4058
+
+    # Enum that maps the :cl_device_partition_property_ext type
+    class PartitionEXT < EnumInt
+      EQUALLY_EXT = 0x4050
+      BY_COUNTS_EXT = 0x4051
+      BY_COUNTS_LIST_END_EXT = 0x0
+      BY_NAMES_EXT = 0x4052
+      BY_AFFINITY_DOMAIN_EXT = 0x4053
+      BY_NAMES_LIST_END_EXT = -1
+      @codes = {}
+      @codes[0x4050] = 'EQUALLY_EXT'
+      @codes[0x4051] = 'BY_COUNTS_EXT'
+      @codes[0x0] = 'BY_COUNTS_LIST_END_EXT'
+      @codes[0x4052] = 'BY_NAMES_EXT'
+      @codes[0x4053] = 'BY_AFFINITY_DOMAIN_EXT'
+      @codes[-1] = 'BY_NAMES_LIST_END_EXT'
+    end
+
+    # Bitfield that maps the :cl_device_affinity_domain_ext type
+    class AffinityDomainEXT < Enum
+      L1_CACHE_EXT = 0x1
+      L2_CACHE_EXT = 0x2
+      L3_CACHE_EXT = 0x3
+      L4_CACHE_EXT = 0x4
+      NUMA_EXT = 0x10
+      NEXT_FISSIONABLE_EXT = 0x100
+      @codes = {}
+      @codes[0x1] = 'L1_CACHE_EXT'
+      @codes[0x2] = 'L2_CACHE_EXT'
+      @codes[0x3] = 'L3_CACHE_EXT'
+      @codes[0x4] = 'L4_CACHE_EXT'
+      @codes[0x10] = 'NUMA_EXT'
+      @codes[0x100] = 'NEXT_FISSIONABLE_EXT'
+    end
+
+  end
+
+  module InnerInterface
+    TYPE_CONVERTER[:cl_device_affinity_domain_ext] = Device::AffinityDomainEXT
+  end
+
+  class Device
+
+    # Creates a new Device and retains it if specified and aplicable
+    def initialize(ptr, retain = true)
+      super(ptr)
+      p = platform
+      if p.version_number >= 1.2 and retain then
+        error = OpenCL.clRetainDevice(ptr)
+        error_check( error )
+      elsif p.version_number >= 1.1 and retain and extensions.include? "cl_ext_device_fission" then
+        error = OpenCL.clRetainDeviceEXT(ptr)
+        error_check( error )
+      end
+    end
+
+    # method called at Device deletion, releases the object if aplicable
+    # @private
+    def self.release(ptr)
+      plat = FFI::MemoryPointer::new( Platform )
+      OpenCL.clGetDeviceInfo( ptr, OpenCL::Device::PLATFORM, plat.size, plat, nil)
+      platform = OpenCL::Platform::new(plat.read_pointer)
+      if platform.version_number >= 1.2 then
+        OpenCL.clReleaseDevice(ptr)
+      elsif platform.version_number >= 1.1
+        ext_size = FFI::MemoryPointer::new( :size_t )
+        OpenCL.clGetDeviceInfo( ptr, OpenCL::Device::EXTENSIONS, 0, nil, ext_size)
+        ext = FFI::MemoryPointer::new( ext.read_size_t )
+        OpenCL.clGetDeviceInfo( ptr, OpenCL::Device::EXTENSIONS, ext.size, ext, nil)
+        extensions = ext.read_string.split(" ")
+        if extensions.include? "cl_ext_device_fission" then
+          OpenCL.clReleaseDeviceEXT(ptr)
+        end
+      end
+    end
+
+    module EXTDeviceFission
+      extend InnerGenerator
+
+      # Returns the list of partition types supported by the Device
+      def partition_types_ext
+        ptr1 = MemoryPointer::new( :size_t, 1)
+        error = OpenCL.clGetDeviceInfo(self, PARTITION_TYPES_EXT, 0, nil, ptr1)
+        error_check(error)
+        ptr2 = MemoryPointer::new( ptr1.read_size_t )
+        error = OpenCL.clGetDeviceInfo(self, PARTITION_TYPES_EXT, ptr1.read_size_t, ptr2, nil)
+        error_check(error)
+        arr = ptr2.get_array_of_cl_device_partition_property_ext(0, ptr1.read_size_t/ OpenCL.find_type(:cl_device_partition_property_ext).size)
+        arr.reject! { |e| e == 0 }
+        return arr.collect { |e| PartitionEXT::new(e.to_i) }
+      end
+
+      get_info_array("Device", :cl_device_affinity_domain_ext, "affinity_domains_ext")
+
+      # Returns the parent Device if it exists
+      def parent_device_ext
+        ptr = MemoryPointer::new( Device )
+        error = OpenCL.clGetDeviceInfo(self, PARENT_DEVICE_EXT, Device.size, ptr, nil)
+        error_check(error)
+        return nil if ptr.null?
+        return Device::new(ptr.read_pointer)
+      end
+
+      get_info("Device", :cl_uint, "reference_count_ext")
+
+      def partition_style_ext
+        ptr1 = MemoryPointer::new( :size_t, 1)
+        error = OpenCL.clGetDeviceInfo(self, PARTITION_STYLE_EXT, 0, nil, ptr1)
+        error_check(error)
+        ptr2 = MemoryPointer::new( ptr1.read_size_t )
+        error = OpenCL.clGetDeviceInfo(self, PARTITION_STYLE_EXT, ptr1.read_size_t, ptr2, nil)
+        error_check(error)
+        arr = ptr2.get_array_of_cl_device_partition_property_ext(0, ptr1.read_size_t/ OpenCL.find_type(:cl_device_partition_property).size)
+        return [] if arr.length == 0
+        ptype = arr.first.to_i
+        arr_2 = []
+        arr_2.push( PartitionEXT::new(ptype) )
+        return arr_2 if arr.length == 1
+        case ptype
+        when PartitionEXT::BY_NAMES_EXT
+          i = 1
+          while arr[i].to_i - (0x1 << Pointer.size * 8) != PartitionEXT::BY_NAMES_LIST_END_EXT do
+            arr_2.push( arr[i].to_i )
+            i += 1
+            return arr_2 if arr.length <= i
+          end
+          arr_2.push( PartitionEXT::new(PartitionEXT::BY_NAMES_LIST_END_EXT) )
+          arr_2.push( 0 )
+        when PartitionEXT::EQUALLY_EXT
+          arr_2.push(arr[1].to_i)
+          arr_2.push( 0 )
+        when PartitionEXT::BY_COUNTS_EXT
+          i = 1
+          while arr[i].to_i != PartitionEXT::BY_COUNTS_LIST_END_EXT do
+            arr_2.push( arr[i].to_i )
+            i += 1
+            return arr_2 if arr.length <= i
+          end
+          arr_2.push( PartitionEXT::new(PartitionEXT::BY_COUNTS_LIST_END_EXT) )
+          arr_2.push( 0 )
+        end
+        return arr_2
+      end
+
+      def create_sub_devices_ext( properties )
+        OpenCL.create_sub_devices_ext( self, properties )
+      end
+
+      def partition_by_affinity_domain_ext( affinity_domain = AffinityDomainEXT::NEXT_FISSIONABLE_EXT )
+        return OpenCL.create_sub_devices_ext( self,  [ PartitionEXT::BY_AFFINITY_DOMAIN_EXT, affinity_domain ] )
+      end
+
+      def partition_equally_ext( compute_unit_number = 1 )
+        return OpenCL.create_sub_devices_ext( self,  [ PartitionEXT::EQUALLY_EXT, compute_unit_number ] )
+      end
+
+      def partition_by_counts_ext( *compute_unit_count_list )
+        compute_unit_count_list = [1] if compute_unit_count_list == []
+        compute_unit_count_list.flatten!
+        return OpenCL.create_sub_devices_ext( self,  [ PartitionEXT::BY_COUNTS_EXT] + compute_unit_count_list + [ PartitionEXT::BY_COUNTS_LIST_END_EXT ] )
+      end
+
+      def partition_by_names_ext( *compute_unit_name_list )
+        compute_unit_name_list = [0] if compute_unit_name_list == []
+        compute_unit_name_list.flatten!
+        return OpenCL.create_sub_devices_ext( self,  [ PartitionEXT::BY_NAMES_EXT ] + compute_unit_name_list + [ PartitionEXT::BY_NAMES_LIST_END_EXT ] )
+      end
+
+    end
+
+     register_extension( :cl_ext_device_fission,  EXTDeviceFission, "extensions.include?(\"cl_ext_device_fission\")" )
+
+  end
+
+end

data/lib/opencl_ruby_ffi/gl_ext.rb

@@ -0,0 +1,2 @@
+require "opencl_ruby_ffi/khr/gl_event.rb"
+require "opencl_ruby_ffi/khr/gl_sharing.rb"

data/lib/opencl_ruby_ffi/khr/d3d10_sharing.rb

@@ -0,0 +1,120 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  INVALID_D3D10_DEVICE_KHR = -1002
+  INVALID_D3D10_RESOURCE_KHR = -1003
+  D3D10_RESOURCE_ALREADY_ACQUIRED_KHR = -1004
+  D3D10_RESOURCE_NOT_ACQUIRED_KHR = -1005
+
+  D3D10_DEVICE_KHR = 0x4010
+  D3D10_DXGI_ADAPTER_KHR = 0x4011
+  PREFERRED_DEVICES_FOR_D3D10_KHR = 0x4012
+  ALL_DEVICES_FOR_D3D10_KHR = 0x4013
+  CONTEXT_D3D10_DEVICE_KHR = 0x4014
+  CONTEXT_D3D10_PREFER_SHARED_RESOURCES_KHR = 0x402C
+  MEM_D3D10_RESOURCE_KHR = 0x4015
+  IMAGE_D3D10_SUBRESOURCE_KHR = 0x4016
+  COMMAND_ACQUIRE_D3D10_OBJECTS_KHR = 0x4017
+  COMMAND_RELEASE_D3D10_OBJECTS_KHR = 0x4018
+
+  class Error
+
+    eval error_class_constructor( :INVALID_D3D10_DEVICE_KHR,            :InvalidD3D10DeviceKHR )
+    eval error_class_constructor( :INVALID_D3D10_RESOURCE_KHR,          :InvalidD3D10ResourceKHR )
+    eval error_class_constructor( :D3D10_RESOURCE_ALREADY_ACQUIRED_KHR, :D3D10ResourceAlreadyAcquiredKHR )
+    eval error_class_constructor( :D3D10_RESOURCE_NOT_ACQUIRED_KHR,     :D3D10ResourceNotAcquiredKHR )
+
+  end
+
+  class Context
+    D3D10_DEVICE_KHR = 0x4014
+    D3D10_PREFER_SHARED_RESOURCES_KHR = 0x402C
+
+    class Properties
+      D3D10_DEVICE_KHR = 0x4014
+      D3D10_PREFER_SHARED_RESOURCES_KHR = 0x402C
+      @codes[0x4014] = 'D3D10_DEVICE_KHR'
+      @codes[0x402C] = 'D3D10_PREFER_SHARED_RESOURCES_KHR'
+    end
+
+  end
+
+  class Mem
+    D3D10_RESOURCE_KHR = 0x4015
+  end
+
+  class Image
+    D3D10_SUBRESOURCE_KHR = 0x4016
+  end
+
+  class CommandType
+    ACQUIRE_D3D10_OBJECTS_KHR = 0x4017
+    RELEASE_D3D10_OBJECTS_KHR = 0x4018
+    @codes[0x4017] = 'ACQUIRE_D3D10_OBJECTS_KHR'
+    @codes[0x4018] = 'RELEASE_D3D10_OBJECTS_KHR'
+  end
+
+  [
+    [ "clGetDeviceIDsFromD3D10KHR",
+      :cl_int,
+      [ Platform,
+        :cl_d3d10_device_source_khr,
+        :pointer,
+        :cl_d3d10_device_set_khr,
+        :cl_uint,
+        :pointer,
+        :pointer
+      ]
+    ], [
+      "clCreateFromD3D10BufferKHR",
+      Mem,
+      [ Context,
+        :cl_mem_flags,
+        :pointer,
+        :pointer ]
+    ], [
+      "clCreateFromD3D10Texture2DKHR",
+      Mem,
+      [ Context, 
+        :cl_mem_flags, 
+        :pointer,
+        :cl_uint,
+        :pointer
+      ]
+    ], [
+      "clCreateFromD3D10Texture3DKHR",
+      Mem,
+      [ Context, 
+        :cl_mem_flags, 
+        :pointer,
+        :cl_uint,
+        :pointer
+      ]
+    ], [
+      "clEnqueueAcquireD3D10ObjectsKHR",
+      :cl_int,
+      [ CommandQueue,
+        :cl_uint,
+        :pointer,
+        :cl_uint,
+        :pointer,
+        :pointer,
+      ]
+    ], [
+      "clEnqueueReleaseD3D10ObjectsKHR",
+      :cl_int,
+      [ CommandQueue,
+        :cl_uint,
+        :pointer,
+        :cl_uint,
+        :pointer,
+        :pointer,
+      ]
+    ]
+  ].each { |name, return_type, args|
+    attach_extension_function(name, return_type, args)
+  }
+
+end