opencl_ruby_ffi 1.3.6 → 1.3.7

data/lib/opencl_ruby_ffi/Platform.rb

@@ -63,6 +63,7 @@ module OpenCL
 
   # Returns an Array of Platform containing the available OpenCL platforms
   def self.get_platforms
+    return @_platforms if @_platforms
     ptr1 = MemoryPointer::new(:cl_uint , 1)
     
     error = clGetPlatformIDs(0, nil, ptr1)
@@ -70,9 +71,10 @@ module OpenCL
     ptr2 = MemoryPointer::new(:pointer, ptr1.read_uint)
     error = clGetPlatformIDs(ptr1.read_uint(), ptr2, nil)
     error_check(error)
-    return ptr2.get_array_of_pointer(0,ptr1.read_uint()).collect { |platform_ptr|
+    @_platforms = ptr2.get_array_of_pointer(0,ptr1.read_uint()).collect { |platform_ptr|
       Platform::new(platform_ptr, false)
     }
+    return @_platforms
   end
 
   class << self
@@ -88,11 +90,11 @@ module OpenCL
       return "#<#{self.class.name}: #{self.name}>"
     end
 
-    get_info("Platform", :string, "profile")
-    get_info("Platform", :string, "version")
-    get_info("Platform", :string, "name")
+    get_info("Platform", :string, "profile", true)
+    get_info("Platform", :string, "version", true)
+    get_info("Platform", :string, "name", true)
     alias to_s name
-    get_info("Platform", :string, "vendor")
+    get_info("Platform", :string, "vendor", true)
 
     # Returns an Array of string corresponding to the Platform extensions
     def extensions
@@ -175,7 +177,7 @@ module OpenCL
     module OpenCL21
       extend InnerGenerator
 
-      get_info("Platform", :cl_ulong, "host_timer_resolution")
+      get_info("Platform", :cl_ulong, "host_timer_resolution", true)
 
     end
 

data/lib/opencl_ruby_ffi/Program.rb

@@ -15,12 +15,20 @@ module OpenCL
   # * +:options+ - a String containing the options to use for the build
   # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
   def self.build_program(program, options = {}, &block)
-    @@callbacks.push( block ) if block
+    if block
+      wrapper_block = lambda { |p, u|
+        block.call(p, u)
+        @@callbacks.delete(wrapper_block)
+      }
+      @@callbacks[wrapper_block] = options[:user_data]
+    else
+      wrapper_block = nil
+    end
     num_devices, devices_p = get_device_list( options )
     opt = ""
     opt = options[:options] if options[:options]
     options_p = MemoryPointer.from_string(opt)
-    error = clBuildProgram(program, num_devices, devices_p, options_p, block, options[:user_data] )
+    error = clBuildProgram(program, num_devices, devices_p, options_p, wrapper_block, options[:user_data] )
     error_check(error)
     return program
   end
@@ -40,7 +48,15 @@ module OpenCL
   # * +:options+ - a String containing the options to use for the build
   # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
   def self.link_program(context, input_programs, options = {}, &block)
-    @@callbacks.push( block ) if block
+    if block
+      wrapper_block = lambda { |p, u|
+        block.call(p, u)
+        @@callbacks.delete(wrapper_block)
+      }
+      @@callbacks[wrapper_block] = options[:user_data]
+    else
+      wrapper_block = nil
+    end
     num_devices, devices_p = get_device_list( options )
     opt = ""
     opt = options[:options] if options[:options]
@@ -50,7 +66,7 @@ module OpenCL
     programs_p = MemoryPointer::new( Program, num_programs )
     programs_p.write_array_of_pointer(programs)
     error = MemoryPointer::new( :cl_int )
-    prog = clLinkProgram( context, num_devices, devices_p, options_p, num_programs, programs_p, block, options[:user_data], error)
+    prog = clLinkProgram( context, num_devices, devices_p, options_p, num_programs, programs_p, wrapper_block, options[:user_data], error)
     error_check(error.read_cl_int)
     return Program::new( prog, false )
   end
@@ -70,7 +86,15 @@ module OpenCL
   # * +:options+ - a String containing the options to use for the compilation
   # * +:input_headers+ - a Hash containing pairs of : String: header_include_name => Program: header
   def self.compile_program(program, options = {}, &block)
-    @@callbacks.push( block ) if block
+    if block
+      wrapper_block = lambda { |p, u|
+        block.call(p, u)
+        @@callbacks.delete(wrapper_block)
+      }
+      @@callbacks[wrapper_block] = options[:user_data]
+    else
+      wrapper_block = nil
+    end
     num_devices, devices_p = get_device_list( options )
     opt = ""
     opt = options[:options] if options[:options]
@@ -80,7 +104,7 @@ module OpenCL
     header_include_names = nil
     num_headers = 0
     num_headers = headers.length if headers
-    if num_headers then
+    if num_headers > 0 then
       headers_p = MemoryPointer::new( Program, num_headers )
       header_include_names = MemoryPointer::new( :pointer, num_headers )
       indx = 0
@@ -90,7 +114,7 @@ module OpenCL
         indx = indx + 1
       }
     end
-    error = clCompileProgram(program, num_devices, devices_p, options_p, num_headers, headers_p, header_include_names, block, options[:user_data] )
+    error = clCompileProgram(program, num_devices, devices_p, options_p, num_headers, headers_p, header_include_names, wrapper_block, options[:user_data] )
     error_check(error)
     return program
   end
@@ -125,10 +149,10 @@ module OpenCL
   # * +device_list+ - an Array of Device to create the program for. Can throw an Error::INVALID_VALUE if the number of supplied devices is different from the number of supplied binaries.
   # * +binaries+ - Array of binaries 
   def self.create_program_with_binary(context, device_list, binaries)
-    bins = [binaries].flatten
-    num_devices = bins.length
+    binaries = [binaries].flatten
+    num_devices = binaries.length
     devices = [device_list].flatten
-    error_check(INVALID_VALUE) if devices.length != bins.length
+    error_check(INVALID_VALUE) if devices.length != binaries.length
     devices_p = MemoryPointer::new( Device, num_devices )
     lengths = MemoryPointer::new( :size_t, num_devices )
     binaries_p = MemoryPointer::new( :pointer, num_devices )
@@ -215,8 +239,16 @@ module OpenCL
   #
   # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
   def self.set_program_release_callback( program, options = {}, &block )
-    @@callbacks.push( block ) if block
-    error = clSetProgramReleaseCallback( program, block, options[:user_data] )
+    if block
+      wrapper_block = lambda { |p, u|
+        block.call(p, u)
+        @@callbacks.delete(wrapper_block)
+      }
+      @@callbacks[wrapper_block] = options[:user_data]
+    else
+      wrapper_block = nil
+    end
+    error = clSetProgramReleaseCallback( program, wrapper_block, options[:user_data] )
     error_check(error)
     return program
   end
@@ -270,26 +302,35 @@ module OpenCL
       end
     end
 
+    # Returns the Platform associated with the Program
+    def platform
+      return @_platform if @_platform
+      @_platform = self.context.platform
+    end
+
     # Returns the Context the Program is associated to
     def context
+      return @_context if @_context
       ptr = MemoryPointer::new( Context )
       error = OpenCL.clGetProgramInfo(self, CONTEXT, Context.size, ptr, nil)
       error_check(error)
-      return Context::new( ptr.read_pointer )
+      @_context = Context::new( ptr.read_pointer )
     end
 
-    get_info("Program", :cl_uint, "num_devices")
+    get_info("Program", :cl_uint, "num_devices", true)
     get_info("Program", :cl_uint, "reference_count")
 
     # Returns the Array of Device the Program is associated with
     def devices
+      return @_devices if @_devices
       n = self.num_devices
       ptr2 = MemoryPointer::new( Device, n )
       error = OpenCL.clGetProgramInfo(self, DEVICES, Device.size*n, ptr2, nil)
       error_check(error)
-      return ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
+      @_devices = ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
         Device::new(device_ptr)
       }
+      return @_devices
     end
 
     get_info("Program", :string, "source")
@@ -462,7 +503,7 @@ module OpenCL
         il_size = MemoryPointer::new( :size_t )
         error = OpenCL.clGetProgramInfo(self, IL, 0, nil, il_size)
         error_check(error)
-        return nil if il_size == 0
+        return nil if il_size.read_size_t == 0
         length = il_size.read_size_t
         il_p = MemoryPointer::new( length )
         error = OpenCL.clGetProgramInfo(self, IL, length, il_p, nil)

data/lib/opencl_ruby_ffi/SVM.rb

@@ -5,7 +5,7 @@ module OpenCL
   class SVMPointer < Pointer
 
     # create a new SVMPointer from its address and the context it pertains to
-    def initialize( address, context, size, base = nil )
+    def initialize( address, context, base = nil )
       super( address )
       @context = context
       if base then
@@ -13,16 +13,20 @@ module OpenCL
       else
         @base = address
       end
-      @size = size
     end
 
     def inspect
-      return "#<#{self.class.name}: #{@size}>"
+      return "#<#{self.class.name}: 0x#{address.to_s(16)} (#{size})>"
+    end
+
+    def slice(offset, size)
+      res = super(offset, size)
+      return slef.class.new( res, @context, @base )
     end
 
     # creates a new SVMPointer relative to an existing one from an offset
     def +( offset )
-      return SVMPointer::new(  self.address + offset, @context, @size, @base )
+      self.slice(offset, self.size - offset)
     end
 
     # frees the parent memory region associated to this SVMPointer
@@ -51,7 +55,7 @@ module OpenCL
     alignment = options[:alignment] if options[:alignment]
     ptr = clSVMAlloc( context, flags, size, alignment )
     error_check(MEM_OBJECT_ALLOCATION_FAILURE) if ptr.null?
-    return SVMPointer::new( ptr, context, size )
+    return SVMPointer::new( ptr.slice(0, size), context )
   end
 
   # Frees an SVMPointer
@@ -112,11 +116,11 @@ module OpenCL
   # * +command_queue+ - CommandQueue used to execute the write command
   # * +dst_ptr+ - the Pointer (or convertible to Pointer using to_ptr) or SVMPointer to be written to
   # * +src_ptr+ - the Pointer (or convertible to Pointer using to_ptr) or SVMPointer to be read from
-  # * +size+ - the size of data to copy
   # * +options+ - a hash containing named options
   #
   # ==== Options
   #
+  # * +:size+ - the size of data to copy
   # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
   # * +:blocking_copy+ - if provided indicates if the command blocks until the copy finishes
   # * +:blocking+ - if provided indicates if the command blocks until the copy finishes
@@ -124,10 +128,12 @@ module OpenCL
   # ==== Returns
   #
   # the Event associated with the command
-  def self.enqueue_svm_memcpy(command_queue, dst_ptr, src_ptr, size, options = {})
+  def self.enqueue_svm_memcpy(command_queue, dst_ptr, src_ptr, options = {})
     error_check(INVALID_OPERATION) if command_queue.context.platform.version_number < 2.0
     blocking = FALSE
     blocking = TRUE if options[:blocking] or options[:blocking_copy]
+    size = [dst_ptr.size, src_ptr.size].min
+    size = options[:size] if options[:size]
     num_events, events = get_event_wait_list( options )
     event = MemoryPointer::new( Event )
     error = clEnqueueSVMMemcpy(command_queue, blocking, dst_ptr, src_ptr, size, num_events, events, event)
@@ -142,10 +148,10 @@ module OpenCL
   # * +command_queue+ - CommandQueue used to execute the write command
   # * +svm_ptr+ - the SVMPointer to the area to fill
   # * +pattern+ - the Pointer (or convertible to Pointer using to_ptr) to the memory area where the pattern is stored
-  # * +size+ - the size of the area to fill
   #
   # ==== Options
   #
+  # * +:size+ - the size of the area to fill
   # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
   # * +:pattern_size+ - if provided indicates the size of the pattern, else the maximum pattern data is used
   #
@@ -157,24 +163,28 @@ module OpenCL
     num_events, events = get_event_wait_list( options )
     pattern_size = pattern.size
     pattern_size = options[:pattern_size] if options[:pattern_size]
+    size = svm_ptr.size
+    size = options[:size] if options[:size]
     event = MemoryPointer::new( Event )
     error = clEnqueueSVMMemFill(command_queue, svm_ptr, pattern, pattern_size, size, num_events, events, event)
     error_check(error)
     return Event::new(event.read_pointer, false)
   end
 
+  singleton_class.send(:alias_method, :enqueue_svm_mem_fill, :enqueue_svm_memfill)
+
   # Enqueues a command to map an Image into host memory
   #
   # ==== Attributes
   # 
   # * +command_queue+ - CommandQueue used to execute the map command
   # * +svm_ptr+ - the SVMPointer to the area to map
-  # * +size+ - the size of the region to map
   # * +map_flags+ - a single or an Array of :cl_map_flags flags
   # * +options+ - a hash containing named options
   #
   # ==== Options
   #
+  # * +:size+ - the size of the region to map
   # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
   # * +:blocking_map+ - if provided indicates if the command blocks until the region is mapped
   # * +:blocking+ - if provided indicates if the command blocks until the region is mapped
@@ -182,11 +192,13 @@ module OpenCL
   # ==== Returns
   #
   # the Event associated with the command
-  def self.enqueue_svm_map( command_queue, svm_ptr, size, map_flags, options = {} )
+  def self.enqueue_svm_map( command_queue, svm_ptr, map_flags, options = {} )
     error_check(INVALID_OPERATION) if command_queue.context.platform.version_number < 2.0
     blocking = FALSE
     blocking = TRUE if options[:blocking] or options[:blocking_map]
     flags = get_flags( {:flags => map_flags} )
+    size = svm_ptr.size
+    size = options[:size] if options[:size]
     num_events, events = get_event_wait_list( options )
     event = MemoryPointer::new( Event )
     error = clEnqueueSVMMap( command_queue, blocking, flags, svm_ptr, size, num_events, events, event )
@@ -251,7 +263,7 @@ module OpenCL
       sizes_p[i].write_size_t(sizes[i])
     }
     event = MemoryPointer::new( Event )
-    error =  clEnqueueSVMMigrateMem( command_queue, num_svm_pointers, svn_ptrs_p, sizes_p, flags, num_events, events, event )
+    error = clEnqueueSVMMigrateMem( command_queue, num_svm_pointers, svn_ptrs_p, sizes_p, flags, num_events, events, event )
     error_check( error )
     return Event::new( event.read_pointer, false )
   end

data/lib/opencl_ruby_ffi/Sampler.rb

@@ -71,10 +71,11 @@ module OpenCL
 
     # Returns the context associated with the Sampler
     def context
+      return @_context if @_context
       ptr = MemoryPointer::new( Context )
       error = OpenCL.clGetSamplerInfo(self, CONTEXT, Context.size, ptr, nil)
       error_check(error)
-      return Context::new( ptr.read_pointer )
+      @_context = Context::new( ptr.read_pointer )
     end
 
     get_info("Sampler", :cl_uint, "reference_count")

data/lib/opencl_ruby_ffi/intel/kernel_profiling.rb

@@ -0,0 +1,38 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+module OpenCL
+
+  CONTEXT_KERNEL_PROFILING_MODES_COUNT_INTEL = 0x407A
+  CONTEXT_KERNEL_PROFILING_MODE_INFO_INTEL = 0x407B
+  KERNEL_IL_SYMBOLS_INTEL = 0x407C
+  KERNEL_BINARY_PROGRAM_INTEL = 0x407D
+
+  class Kernel
+    IL_SYMBOLS_INTEL = 0x407C
+    BINARY_PROGRAM_INTEL = 0x407D
+    module KernelProfilingINTEL
+      def binary_program_intel(device = program.devices.first)
+        ptr_bin = nil
+        begin
+        ptr = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetKernelWorkGroupInfo(self, device, BINARY_PROGRAM_INTEL, 0, nil, ptr)
+        error_check(error)
+        bin_size = ptr.read_size_t
+        ptr_bin = MemoryPointer::new(bin_size)
+        error = OpenCL.clGetKernelWorkGroupInfo(self, device, BINARY_PROGRAM_INTEL, bin_size, ptr_bin, nil)
+        error_check(error)
+        rescue OpenCL::Error::INVALID_VALUE
+          ptr = MemoryPointer::new( :size_t )
+          error = OpenCL.clGetKernelInfo(self, BINARY_PROGRAM_INTEL, 0, nil, ptr)
+          error_check(error)
+          bin_size = ptr.read_size_t
+          ptr_bin = MemoryPointer::new(bin_size)
+          error = OpenCL.clGetKernelInfo(self, BINARY_PROGRAM_INTEL, bin_size, ptr_bin, nil)
+          error_check(error)
+        end
+        return ptr_bin.read_bytes(bin_size)
+      end
+    end
+    register_extension(:cl_intel_kernel_profiling, KernelProfilingINTEL, "true")
+  end
+
+end

data/lib/opencl_ruby_ffi/intel/unified_shared_memory_preview.rb

@@ -0,0 +1,586 @@
+module OpenCL
+  DEVICE_HOST_MEM_CAPABILITIES_INTEL = 0x4190
+  DEVICE_DEVICE_MEM_CAPABILITIES_INTEL = 0x4191
+  DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL = 0x4192
+  DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL = 0x4193
+  DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL = 0x4194
+
+  UNIFIED_SHARED_MEMORY_ACCESS_INTEL = (1 << 0)
+  UNIFIED_SHARED_MEMORY_ATOMIC_ACCESS_INTEL = (1 << 1)
+  UNIFIED_SHARED_MEMORY_CONCURRENT_ACCESS_INTEL = (1 << 2)
+  UNIFIED_SHARED_MEMORY_CONCURRENT_ATOMIC_ACCESS_INTEL = (1 << 3)
+
+  MEM_ALLOC_FLAGS_INTEL = 0x4195
+
+  MEM_ALLOC_WRITE_COMBINED_INTEL = (1 << 0)
+
+  MEM_TYPE_UNKNOWN_INTEL = 0x4196
+  MEM_TYPE_HOST_INTEL = 0x4197
+  MEM_TYPE_DEVICE_INTEL = 0x4198
+  MEM_TYPE_SHARED_INTEL = 0x4199
+
+  MEM_ALLOC_TYPE_INTEL = 0x419A
+  MEM_ALLOC_BASE_PTR_INTEL = 0x419B
+  MEM_ALLOC_SIZE_INTEL = 0x419C
+  MEM_ALLOC_DEVICE_INTEL = 0x419D
+  MEM_ALLOC_INFO_TBD1_INTEL = 0x419E
+  MEM_ALLOC_INFO_TBD2_INTEL = 0x419F
+
+  KERNEL_EXEC_INFO_INDIRECT_HOST_ACCESS_INTEL = 0x4200
+  KERNEL_EXEC_INFO_INDIRECT_DEVICE_ACCESS_INTEL = 0x4201
+  KERNEL_EXEC_INFO_INDIRECT_SHARED_ACCESS_INTEL = 0x4202
+  KERNEL_EXEC_INFO_USM_PTRS_INTEL = 0x4203
+
+  MIGRATE_MEM_OBJECT_HOST_INTEL = (1 << 0)
+  MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED_INTEL = (1 << 1)
+
+  COMMAND_MEMFILL_INTEL = 0x4204
+  COMMAND_MEMCPY_INTEL = 0x4205
+  COMMAND_MIGRATEMEM_INTEL = 0x4206
+  COMMAND_MEMADVISE_INTEL = 0x4207
+
+  class CommandType
+    MEMFILL_INTEL = 0x4204
+    MEMCPY_INTEL = 0x4205
+    MIGRATEMEM_INTEL = 0x4206
+    MEMADVISE_INTEL = 0x4207
+
+    @codes[0x4204] = 'MEMFILL_INTEL'
+    @codes[0x4205] = 'MEMCPY_INTEL'
+    @codes[0x4206] = 'MIGRATEMEM_INTEL'
+    @codes[0x4207] = 'MEMADVISE_INTEL'
+  end
+
+  MEM_ADVICE_TBD0_INTEL = 0x4208
+  MEM_ADVICE_TBD1_INTEL = 0x4209
+  MEM_ADVICE_TBD2_INTEL = 0x420A
+  MEM_ADVICE_TBD3_INTEL = 0x420B
+  MEM_ADVICE_TBD4_INTEL = 0x420C
+  MEM_ADVICE_TBD5_INTEL = 0x420D
+  MEM_ADVICE_TBD6_INTEL = 0x420E
+  MEM_ADVICE_TBD7_INTEL = 0x420F
+
+  [[:cl_bitfield, :cl_mem_properties_intel],
+   [:cl_bitfield, :cl_mem_migration_flags_intel],
+   [:cl_bitfield, :cl_mem_alloc_flags_intel],
+   [:cl_uint, :cl_mem_info_intel],
+   [:cl_uint, :cl_mem_advice_intel],
+   [:cl_bitfield, :cl_unified_shared_memory_capabilities_intel],
+   [:cl_uint, :cl_unified_shared_memory_type_intel]
+  ].each { |o_t, t|
+    typedef o_t, t
+  }
+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_bitfield, :cl_mem_properties_intel],
+       [:cl_bitfield, :cl_mem_migration_flags_intel],
+       [:cl_bitfield, :cl_mem_alloc_flags_intel],
+       [:cl_uint, :cl_mem_info_intel],
+       [:cl_uint, :cl_mem_advice_intel],
+       [:cl_bitfield, :cl_unified_shared_memory_capabilities_intel],
+       [:cl_uint, :cl_unified_shared_memory_type_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_bitfield, :cl_mem_properties_intel],
+     [:cl_bitfield, :cl_mem_migration_flags_intel],
+     [:cl_bitfield, :cl_mem_alloc_flags_intel],
+     [:cl_uint, :cl_mem_info_intel],
+     [:cl_uint, :cl_mem_advice_intel],
+     [:cl_bitfield, :cl_unified_shared_memory_capabilities_intel],
+     [:cl_uint, :cl_unified_shared_memory_type_intel]
+    ].each { |orig, add|
+      methods_prefix.each { |meth|
+        alias_method "#{meth}_#{add}".to_sym, "#{meth}_#{orig}".to_sym
+      }
+    }
+  end
+end
+
+module OpenCL
+
+  class UnifiedSharedMemoryCapabilitiesINTEL < Bitfield
+    UNIFIED_SHARED_MEMORY_ACCESS_INTEL = (1 << 0)
+    UNIFIED_SHARED_MEMORY_ATOMIC_ACCESS_INTEL = (1 << 1)
+    UNIFIED_SHARED_MEMORY_CONCURRENT_ACCESS_INTEL = (1 << 2)
+    UNIFIED_SHARED_MEMORY_CONCURRENT_ATOMIC_ACCESS_INTEL = (1 << 3)
+
+    def names
+      fs = []
+      %w( UNIFIED_SHARED_MEMORY_ACCESS_INTEL UNIFIED_SHARED_MEMORY_ATOMIC_ACCESS_INTEL UNIFIED_SHARED_MEMORY_CONCURRENT_ACCESS_INTEL UNIFIED_SHARED_MEMORY_CONCURRENT_ATOMIC_ACCESS_INTEL )..each { |f|
+        fs.push(f) if self.include?( self.class.const_get(f) )
+      }
+      return fs
+    end
+  end
+
+  module InnerInterface
+    TYPE_CONVERTER[:cl_unified_shared_memory_capabilities_intel] = UnifiedSharedMemoryCapabilitiesINTEL
+  end
+
+  class Mem
+    ALLOC_FLAGS_INTEL = 0x4195
+
+    TYPE_UNKNOWN_INTEL = 0x4196
+    TYPE_HOST_INTEL = 0x4197
+    TYPE_DEVICE_INTEL = 0x4198
+    TYPE_SHARED_INTEL = 0x4199
+
+    ALLOC_WRITE_COMBINED_INTEL = (1 << 0)
+
+    ALLOC_TYPE_INTEL = 0x419A
+    ALLOC_BASE_PTR_INTEL = 0x419B
+    ALLOC_SIZE_INTEL = 0x419C
+    ALLOC_DEVICE_INTEL = 0x419D
+    ALLOC_INFO_TBD1_INTEL = 0x419E
+    ALLOC_INFO_TBD2_INTEL = 0x419F
+
+    class UnifiedSharedMemoryTypeINTEL < EnumInt
+      UNKNOWN_INTEL = 0x4196
+      HOST_INTEL = 0x4197
+      DEVICE_INTEL = 0x4198
+      SHARED_INTEL = 0x4199
+      @codes = {}
+      @codes[0x4196] = 'UNKNOWN_INTEL'
+      @codes[0x4197] = 'HOST_INTEL'
+      @codes[0x4198] = 'DEVICE_INTEL'
+      @codes[0x4199] = 'SHARED_INTEL'
+    end
+
+    class AllocFlagsINTEL < Bitfield
+      DEFAULT_INTEL = 0
+      WRITE_COMBINED_INTEL = (1 << 0)
+      def names
+        fs = []
+        %w( WRITE_COMBINED_INTEL ).each { |f|
+          fs.push(f) if self.include?( self.class.const_get(f) )
+        }
+        return fs
+      end
+    end
+
+    class AdviceINTEL < EnumInt
+      TBD0_INTEL = 0x4208
+      TBD1_INTEL = 0x4209
+      TBD2_INTEL = 0x420A
+      TBD3_INTEL = 0x420B
+      TBD4_INTEL = 0x420C
+      TBD5_INTEL = 0x420D
+      TBD6_INTEL = 0x420E
+      TBD7_INTEL = 0x420F
+      @codes = {}
+      @codes[0x4208] = 'TBD0_INTEL'
+      @codes[0x4209] = 'TBD1_INTEL'
+      @codes[0x420A] = 'TBD2_INTEL'
+      @codes[0x420B] = 'TBD3_INTEL'
+      @codes[0x420C] = 'TBD4_INTEL'
+      @codes[0x420D] = 'TBD5_INTEL'
+      @codes[0x420E] = 'TBD6_INTEL'
+      @codes[0x420F] = 'TBD7_INTEL'
+    end
+
+    class MigrationFlagsINTEL < Bitfield
+      HOST_INTEL = (1 << 0)
+      CONTENT_UNDEFINED_INTEL = (1 << 1)
+      # Returns an Array of String representing the different flags set
+      def names
+        fs = []
+        %w( HOST CONTENT_UNDEFINED ).each { |f|
+          fs.push(f) if self.include?( self.class.const_get(f) )
+        }
+        return fs
+      end
+    end
+
+  end
+
+  module InnerInterface
+    TYPE_CONVERTER[:cl_unified_shared_memory_type_intel] = Mem::UnifiedSharedMemoryTypeINTEL
+    TYPE_CONVERTER[:cl_mem_alloc_flags_intel] = Mem::AllocFlagsINTEL
+    TYPE_CONVERTER[:cl_mem_advice_intel] = Mem::AdviceINTEL
+    TYPE_CONVERTER[:cl_mem_migration_flags_intel] = Mem::MigrationFlagsINTEL
+  end
+
+  class Device
+    HOST_MEM_CAPABILITIES_INTEL = 0x4190
+    DEVICE_MEM_CAPABILITIES_INTEL = 0x4191
+    SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL = 0x4192
+    CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL = 0x4193
+    SHARED_SYSTEM_MEM_CAPABILITIES_INTEL = 0x4194
+
+    module UnifiedSharedMemoryPreviewINTEL
+      extend InnerGenerator
+
+      get_info("Device", :cl_unified_shared_memory_capabilities_intel, "host_mem_capabilities_intel")
+      get_info("Device", :cl_unified_shared_memory_capabilities_intel, "device_mem_capabilities_intel")
+      get_info("Device", :cl_unified_shared_memory_capabilities_intel, "device_shared_mem_capabilities_intel")
+      get_info("Device", :cl_unified_shared_memory_capabilities_intel, "cross_device_mem_capabilities_intel")
+      get_info("Device", :cl_unified_shared_memory_capabilities_intel, "shared_system_mem_capabilities_intel")
+    end
+    register_extension( :cl_intel_unified_shared_memory_preview, UnifiedSharedMemoryPreviewINTEL, "extensions.include?(\"cl_intel_unified_shared_memory_preview\")" )
+  end
+
+  class USMPointer < Pointer
+
+    def initialize(address, context)
+      super(address)
+      @context = context
+    end
+
+    def inspect
+      return "#<#{self.class.name}: 0x#{address.to_s(16)} (#{size})>"
+    end
+
+    def slice(offset, size)
+      res = super(offset, size)
+      self.class.new(res, context)
+    end
+
+    def +( offset )
+      self.slice(offset, self.size - offset)
+    end
+
+    def free
+      @context.mem_free_intel(alloc_base_ptr_intel)
+    end
+
+    def alloc_type_intel
+      @context.mem_alloc_type_intel(self)
+    end
+
+    def alloc_flags_intel
+      @context.mem_alloc_flags_intel(self)
+    end
+
+    def alloc_base_ptr_intel
+      @context.mem_alloc_base_ptr_intel(self)
+    end
+
+    def alloc_size_intel
+      @context.mem_alloc_size_intel(self)
+    end
+
+    def alloc_device_intel
+      context.mem_alloc_device_intel(self)
+    end
+  end
+
+  class Context
+    module UnifiedSharedMemoryPreviewINTEL
+      extend InnerGenerator
+
+      def clGetMemAllocInfoINTEL
+        return @_clGetMemAllocInfoINTEL if @_clGetMemAllocInfoINTEL
+        @_clGetMemAllocInfoINTEL = platform.get_extension_function("clGetMemAllocInfoINTEL", :cl_int, [Context, :pointer, :cl_mem_info_intel, :size_t, :pointer, :pointer])
+        error_check(OpenCL::INVALID_OPERATION) unless @_clGetMemAllocInfoINTEL
+        return @_clGetMemAllocInfoINTEL
+      end
+
+      def clHostMemAllocINTEL
+        return @_clHostMemAllocINTEL if @_clHostMemAllocINTEL
+        @_clHostMemAllocINTEL = platform.get_extension_function("clHostMemAllocINTEL", :pointer, [Context, :pointer, :size_t, :cl_uint, :pointer])
+        error_check(OpenCL::INVALID_OPERATION) unless @_clHostMemAllocINTEL
+        return @_clHostMemAllocINTEL
+      end
+
+      def clDeviceMemAllocINTEL
+        return @_clDeviceMemAllocINTEL if @_clDeviceMemAllocINTEL
+        @_clDeviceMemAllocINTEL = platform.get_extension_function("clDeviceMemAllocINTEL", :pointer, [Context, Device, :pointer, :size_t, :cl_uint, :pointer])
+        error_check(OpenCL::INVALID_OPERATION) unless @_clDeviceMemAllocINTEL
+        return @_clDeviceMemAllocINTEL
+      end
+
+      def clSharedMemAllocINTEL
+        return @_clSharedMemAllocINTEL if @_clSharedMemAllocINTEL
+        @_clSharedMemAllocINTEL = platform.get_extension_function("clSharedMemAllocINTEL", :pointer, [Context, Device, :pointer, :size_t, :cl_uint, :pointer])
+        error_check(OpenCL::INVALID_OPERATION) unless @_clSharedMemAllocINTEL
+        return @_clSharedMemAllocINTEL
+      end
+
+      def clMemFreeINTEL
+        return @_clMemFreeINTEL if @_clMemFreeINTEL
+        @_clMemFreeINTEL = platform.get_extension_function("clMemFreeINTEL", :cl_int, [Context, :pointer])
+        error_check(OpenCL::INVALID_OPERATION) unless @_clMemFreeINTEL
+        return @_clMemFreeINTEL
+      end
+
+      def get_mem_properties_intel(properties)
+        return nil unless properties
+        properties = [properties].flatten
+        props = MemoryPointer::new(:cl_mem_properties_intel, properties.length + 1)
+        properties.each_with_index { |e, i|
+          props[i].write_cl_mem_properties_intel(e)
+        }
+        props[properties.length].write_cl_mem_properties_intel(0)
+        return props
+      end
+
+      private :get_mem_properties_intel
+
+      def host_mem_alloc_intel(size, options = {})
+        properties = get_mem_properties_intel(options[:properties])
+        alignment = 0
+        alignment = options[:alignment] if options[:alignment]
+        error = MemoryPointer::new( :cl_int )
+        ptr = clHostMemAllocINTEL.call(self, properties, size, alignment, error)
+        error_check(error.read_cl_int)
+        return USMPointer::new(ptr.slice(0, size), self)
+      end
+
+      def device_mem_alloc_intel(device, size, options = {})
+        properties = get_mem_properties_intel(options[:properties])
+        alignment = 0
+        alignment = options[:alignment] if options[:alignment]
+        error = MemoryPointer::new( :cl_int )
+        ptr = clDeviceMemAllocINTEL.call(self, device, properties, size, alignment, error)
+        error_check(error.read_cl_int)
+        return USMPointer::new(ptr.slice(0, size), self)
+      end
+
+      def shared_mem_alloc_intel(device, size, options = {})
+        properties = get_mem_properties_intel(options[:properties])
+        alignment = 0
+        alignment = options[:alignment] if options[:alignment]
+        error = MemoryPointer::new( :cl_int )
+        ptr = clSharedMemAllocINTEL.call(self, device, properties, size, alignment, error)
+        error_check(error.read_cl_int)
+        return USMPointer::new(ptr.slice(0, size), self)
+      end
+
+      def mem_free_intel(ptr)
+        error = clMemFreeINTEL.call(self, ptr)
+        error_check(error)
+        return self
+      end
+
+      def mem_alloc_type_intel(ptr)
+        ptr_res = MemoryPointer::new(:cl_unified_shared_memory_type_intel)
+        error = clGetMemAllocInfoINTEL.call(self, ptr, OpenCL::Mem::ALLOC_TYPE_INTEL, ptr_res.size, ptr_res, nil)
+        error_check(error)
+        return OpenCL::Mem::UnifiedSharedMemoryTypeINTEL::new(ptr_res.read_cl_unified_shared_memory_type_intel)
+      end
+
+      def mem_alloc_flags_intel(ptr)
+        ptr_res = MemoryPointer::new(:cl_mem_alloc_flags_intel)
+        error = clGetMemAllocInfoINTEL.call(self, ptr, OpenCL::Mem::ALLOC_FLAGS_INTEL, ptr_res.size, ptr_res, nil)
+        error_check(error)
+        return OpenCL::Mem::AllocFlagsINTEL::new(ptr_res.read_cl_mem_alloc_flags_intel)
+      end
+
+      def mem_alloc_base_ptr_intel(ptr)
+        ptr_res = MemoryPointer::new(:pointer)
+        error = clGetMemAllocInfoINTEL.call(self, ptr, OpenCL::Mem::ALLOC_BASE_PTR_INTEL, ptr_res.size, ptr_res, nil)
+        error_check(error)
+        return ptr_res.read_pointer
+      end
+
+      def mem_alloc_size_intel(ptr)
+        ptr_res = MemoryPointer::new(:size_t)
+        error = clGetMemAllocInfoINTEL.call(self, ptr, OpenCL::Mem::ALLOC_SIZE_INTEL, ptr_res.size, ptr_res, nil)
+        error_check(error)
+        return ptr_res.read_size_t
+      end
+
+      def mem_alloc_device_intel(ptr)
+        ptr_res = MemoryPointer::new( Device )
+        error = OpenCL.clGetMemAllocInfoINTEL.call(self, ptr, OpenCL::Mem::ALLOC_DEVICE_INTEL, Device.size, ptr_res, nil)
+        error_check(error)
+        return Device::new(ptr_res.read_pointer)
+      end
+
+    end
+    register_extension( :cl_intel_unified_shared_memory_preview, UnifiedSharedMemoryPreviewINTEL, "platform.extensions.include?(\"cl_intel_unified_shared_memory_preview\")" )
+  end
+
+  class Kernel
+    EXEC_INFO_INDIRECT_HOST_ACCESS_INTEL = 0x4200
+    EXEC_INFO_INDIRECT_DEVICE_ACCESS_INTEL = 0x4201
+    EXEC_INFO_INDIRECT_SHARED_ACCESS_INTEL = 0x4202
+    EXEC_INFO_USM_PTRS_INTEL = 0x4203
+
+    module UnifiedSharedMemoryPreviewINTEL
+      extend InnerGenerator
+
+      def clSetKernelArgMemPointerINTEL
+        return @_clSetKernelArgMemPointerINTEL if @_clSetKernelArgMemPointerINTEL
+        @_clSetKernelArgMemPointerINTEL = context.platform.get_extension_function("clSetKernelArgMemPointerINTEL", :cl_int, Kernel, :cl_uint, :pointer)
+        error_check(OpenCL::INVALID_OPERATION) unless @_clSetKernelArgMemPointerINTEL
+        return @_clSetKernelArgMemPointerINTEL
+      end
+
+      def set_arg_mem_pointer_intel(index, usm_pointer)
+        error = clSetKernelArgMemPointerINTEL.call(self, index, usm_pointer)
+        error_check(error)
+        return self 
+      end
+
+      def set_usm_ptrs_intel( ptrs )
+        pointers = [ptrs].flatten
+        pt = MemoryPointer::new( :pointer, pointers.length )
+        pointers.each_with_index { |p, i|
+          pt[i].write_pointer(p)
+        }
+        error = OpenCL.clSetKernelExecInfo( self, EXEC_INFO_USM_PTRS_INTEL, pt.size, pt)
+        error_check(error)
+        self
+      end
+
+      def set_indirect_host_access_intel( flag )
+        pt = MemoryPointer::new(  :cl_bool )
+        pt.write_cl_bool( flag )
+        error = OpenCL.clSetKernelExecInfo( self, EXEC_INFO_INDIRECT_HOST_ACCESS_INTEL, pt.size, pt)
+        error_check(error)
+        self
+      end
+
+      def set_indirect_device_access_intel( flag )
+        pt = MemoryPointer::new(  :cl_bool )
+        pt.write_cl_bool( flag )
+        error = OpenCL.clSetKernelExecInfo( self, EXEC_INFO_INDIRECT_DEVICE_ACCESS_INTEL, pt.size, pt)
+        error_check(error)
+        self
+      end
+
+      def set_shared_device_access_intel( flag )
+        pt = MemoryPointer::new(  :cl_bool )
+        pt.write_cl_bool( flag )
+        error = OpenCL.clSetKernelExecInfo( self, EXEC_INFO_SHARED_DEVICE_ACCESS_INTEL, pt.size, pt)
+        error_check(error)
+        self
+      end
+
+      def enqueue_with_args(command_queue, global_work_size, *args)
+        n = self.num_args
+        error_check(INVALID_KERNEL_ARGS) if args.length < n
+        error_check(INVALID_KERNEL_ARGS) if args.length > n + 1
+        if args.length == n + 1
+          options = args.last
+        else
+          options = {}
+        end
+        n.times { |i|
+          if args[i].class == SVMPointer and self.context.platform.version_number >= 2.0 then
+            self.set_arg_svm_pointer(i, args[i])
+          elsif args[i].class == USMPointer then
+            self.set_arg_mem_pointer_intel(i, args[i])
+          else
+            self.set_arg(i, args[i])
+          end
+        }
+        command_queue.enqueue_ndrange_kernel(self, global_work_size, options)
+      end
+
+    end
+    register_extension( :cl_intel_unified_shared_memory_preview, UnifiedSharedMemoryPreviewINTEL, "platform.extensions.include?(\"cl_intel_unified_shared_memory_preview\")" )
+  end
+
+  class Kernel
+    class Arg
+      module UnifiedSharedMemoryPreviewINTEL
+        def set(value, size = nil)
+          if value.class == SVMPointer and @kernel.context.platform.version_number >= 2.0 then
+            OpenCL.set_kernel_arg_svm_pointer(@kernel, @index, value)
+          elsif args[i].class == USMPointer then
+            @kernel.set_arg_mem_pointer_intel(@index, value)
+          else
+            OpenCL.set_kernel_arg(@kernel, @index, value, size)
+          end
+        end
+      end
+      register_extension( :cl_intel_unified_shared_memory_preview, UnifiedSharedMemoryPreviewINTEL, "platform.extensions.include?(\"cl_intel_unified_shared_memory_preview\")" )
+    end
+  end
+
+  class CommandQueue
+    module UnifiedSharedMemoryPreviewINTEL
+      extend InnerGenerator
+
+      def clEnqueueMemFillINTEL
+        return @_clEnqueueMemFillINTEL if @_clEnqueueMemFillINTEL
+        @_clEnqueueMemFillINTEL = platform.get_extension_function("clEnqueueMemFillINTEL", :cl_int, [CommandQueue, :pointer, :pointer, :size_t, :size_t, :cl_uint, :pointer, :pointer])
+        error_check(OpenCL::INVALID_OPERATION) unless @_clEnqueueMemFillINTEL
+        return @_clEnqueueMemFillINTEL
+      end
+
+      def clEnqueueMemcpyINTEL
+        return @_clEnqueueMemcpyINTEL if @_clEnqueueMemcpyINTEL
+        @_clEnqueueMemcpyINTEL = platform.get_extension_function("clEnqueueMemcpyINTEL", :cl_int, [CommandQueue, :cl_bool, :pointer, :pointer, :size_t, :cl_uint, :pointer, :pointer])
+        error_check(OpenCL::INVALID_OPERATION) unless @_clEnqueueMemcpyINTEL
+        return @_clEnqueueMemcpyINTEL
+      end
+
+      def clEnqueueMigrateMemINTEL
+        return @_clEnqueueMigrateMemINTEL if @_clEnqueueMigrateMemINTEL
+        @_clEnqueueMigrateMemINTEL = platform.get_extension_function("clEnqueueMigrateMemINTEL", :cl_int, [CommandQueue, :pointer, :size_t, :cl_mem_migration_flags_intel, :cl_uint, :pointer, :pointer])
+        error_check(OpenCL::INVALID_OPERATION) unless @_clEnqueueMemcpyINTEL
+        return @_clEnqueueMemcpyINTEL
+      end
+
+      def clEnqueueMemAdviseINTEL
+        return @_clEnqueueMemAdviseINTEL if @_clEnqueueMemAdviseINTEL
+        @_clEnqueueMemAdviseINTEL = platform.get_extension_function("clEnqueueMemAdviseINTEL", :cl_int, [CommandQueue, :pointer, :size_t, :cl_mem_advice_intel, :cl_uint, :pointer, :pointer])
+        error_check(OpenCL::INVALID_OPERATION) unless @_clEnqueueMemAdviseINTEL
+        return @_clEnqueueMemAdviseINTEL
+      end
+
+      def enqueue_mem_fill_intel(usm_ptr, pattern, options = {})
+        num_events, events = get_event_wait_list( options )
+        pattern_size = pattern.size
+        pattern_size = options[:pattern_size] if options[:pattern_size]
+        size = usm_ptr.size
+        size = options[:size] if options[:size]
+        event = MemoryPointer::new( Event )
+        error = clEnqueueMemFillINTEL.call(self, usm_ptr, pattern, pattern_size, size, num_events, events, event)
+        error_check(error)
+        return Event::new(event.read_pointer, false)
+      end
+
+      def enqueue_memcpy_intel(dst_ptr, src_ptr, options = {})
+        num_events, events = get_event_wait_list( options )
+        blocking = FALSE
+        blocking = TRUE if options[:blocking] or options[:blocking_copy]
+        size = [dst_ptr.size, src_ptr.size].min
+        size = options[:size] if options[:size]
+        event = MemoryPointer::new( Event )
+        error = clEnqueueMemcpyINTEL.call(self, blocking, dst_ptr, src_ptr, size, num_events, events, event)
+        error_check(error)
+        return Event::new(event.read_pointer, false)
+      end
+
+      def enqueue_migrate_mem_intel(usm_ptr, options = {})
+        num_events, events = get_event_wait_list( options )
+        flags = get_flags( options )
+        size = usm_ptr.size
+        size = options[:size] if options[:size]
+        event = MemoryPointer::new( Event )
+        error = clEnqueueMigrateMemINTEL.call(self, usm_ptr, size, flags, num_events, events, event)
+        error_check(error)
+        return Event::new(event.read_pointer, false)
+      end
+
+      def enqueue_mem_advise_intel(usm_ptr, advice, options = {})
+        num_events, events = get_event_wait_list( options )
+        size = usm_ptr.size
+        size = options[:size] if options[:size]
+        event = MemoryPointer::new( Event )
+        error = clEnqueueMemAdviseINTEL(self, usm_ptr, size, advice, num_events, events, event)
+        error_check(error)
+        return Event::new(event.read_pointer, false)
+      end
+
+    end
+    register_extension( :cl_intel_unified_shared_memory_preview, UnifiedSharedMemoryPreviewINTEL, "device.extensions.include?(\"cl_intel_unified_shared_memory_preview\")" )
+  end
+end