opencl_ruby_ffi 1.2.2 → 1.3.0

data/lib/opencl_ruby_ffi/Context.rb

@@ -58,24 +58,37 @@ module OpenCL
   #Maps the cl_context object of OpenCL
   class Context
     include InnerInterface
-
-    class << self
-      include InnerGenerator
-    end
+    extend InnerGenerator
 
     def inspect
       return "#<#{self.class.name}: #{self.devices}>"
     end
 
-    ##
-    # :method: reference_count
-    # Returns the reference count of the Context
-    %w( REFERENCE_COUNT ).each { |prop|
-      eval get_info("Context", :cl_uint, prop)
-    }
+    get_info("Context", :cl_uint, "reference_count")
+
+    # Returns the number of devices associated to the Context
+    def num_devices
+      d_n = 0
+      ptr = MemoryPointer::new( :size_t )
+      error = OpenCL.clGetContextInfo(self, DEVICES, 0, nil, ptr)
+      error_check(error)
+      d_n = ptr.read_size_t / Platform.size
+      return d_n
+    end
+
+    # Returns an Array of Device associated to the Context
+    def devices
+      n = self.num_devices
+      ptr2 = MemoryPointer::new( Device, n )
+      error = OpenCL.clGetContextInfo(self, DEVICES, Device.size*n, ptr2, nil)
+      error_check(error)
+      return ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
+        Device::new(device_ptr)
+      }
+    end
 
     ##
-    # :method: properties
+    # @!method properties
     # the Array of :cl_context_properties used to create the Context
     def properties
       ptr1 = MemoryPointer::new( :size_t, 1)
@@ -108,33 +121,6 @@ module OpenCL
       self.devices.first.platform
     end
 
-    # Returns the number of devices associated to the Context
-    def num_devices
-      d_n = 0
-      ptr = MemoryPointer::new( :size_t )
-      error = OpenCL.clGetContextInfo(self, DEVICES, 0, nil, ptr)
-      error_check(error)
-      d_n = ptr.read_size_t / Platform.size
-#      else
-#        ptr = MemoryPointer::new( :cl_uint )
-#        error = OpenCL.clGetContextInfo(self, OpenCL::Context::NUM_DEVICES, ptr.size, ptr, nil)
-#        OpenCL.error_check(error)
-#        d_n = ptr.read_cl_uint
-#      end
-      return d_n
-    end
-
-    # Returns an Array of Device associated to the Context
-    def devices
-      n = self.num_devices
-      ptr2 = MemoryPointer::new( Device, n )
-      error = OpenCL.clGetContextInfo(self, DEVICES, Device.size*n, ptr2, nil)
-      error_check(error)
-      return ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
-        Device::new(device_ptr)
-      }
-    end
-
     # Returns an Array of ImageFormat that are supported for a given image type in the Context
     #
     # ==== Attributes
@@ -214,27 +200,10 @@ module OpenCL
     # ==== Options
     #
     # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image
-    def create_from_gl_render_buffer( renderbuffer, options = {} )
-      return OpenCL.create_from_gl_render_buffer( self, renderbuffer, options )
+    def create_from_gl_renderbuffer( renderbuffer, options = {} )
+      return OpenCL.create_from_gl_renderbuffer( self, renderbuffer, options )
     end
-    alias :create_from_GL_render_buffer :create_from_gl_render_buffer
-
-    # Creates an Image in the Context from an OpenGL texture
-    #
-    # ==== Attributes
-    #
-    # * +texture_target+ - a :GLenum defining the image type of texture
-    # * +texture+ - a :GLuint specifying the name of the texture
-    # * +options+ - a hash containing named options
-    #
-    # ==== Options
-    #
-    # * +:miplevel+ - a :GLint specifying the mipmap level to be used (default 0)
-    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image
-    def create_from_gl_texture( texture_target, texture, options = {} )
-      return OpenCL.create_from_gl_texture( self, texture_target, texture, options )
-    end
-    alias :create_from_GL_texture :create_from_gl_texture
+    alias :create_from_GL_renderbuffer :create_from_gl_renderbuffer
 
     # Creates an Image in the Context from an OpenGL 2D texture
     #
@@ -270,21 +239,6 @@ module OpenCL
     end
     alias :create_from_GL_texture_3D :create_from_gl_texture_3d
 
-    # Creates an Image in the Context
-    #
-    # ==== Attributes
-    #
-    # * +format+ - an ImageFormat
-    # * +options+ - an ImageDesc
-    #
-    # ==== Options
-    # 
-    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
-    # * +:host_ptr+ - if provided, the Pointer (or convertible to Pointer using to_ptr) to the memory area to use
-    def create_image( format, desc, options = {} )
-      return OpenCL.create_image( self, format, desc, options )
-    end
-
     # Creates a 1D Image in the Context
     #
     # ==== Attributes
@@ -336,39 +290,6 @@ module OpenCL
     end
     alias :create_image_3D :create_image_3d
 
-#    # Creates an Event in the Context from a GL sync
-#    #
-#    # ==== Attributes
-#    #
-#    # * +sync+ - a :GLsync representing the name of the sync object
-#    def create_event_from_gl_sync_khr( sync )
-#      return OpenCL.create_event_from_gl_sync_khr( self, sync )
-#    end
-#    alias :create_event_from_GL_sync_KHR :create_event_from_gl_sync_khr
-
-
-    # Creates a user Event in the Context
-    def create_user_event
-      return OpenCL.create_user_event(self)
-    end
-
-    # Links a set of compiled programs for all device in the Context, or a subset of devices
-    #
-    # ==== Attributes
-    #
-    # * +input_programs+ - a single or an Array of Program
-    # * +options+ - a Hash containing named options
-    # * +block+ - if provided, a callback invoked when the Program is built. Signature of the callback is { |Program, Pointer to user_data| ... }
-    #
-    # ==== Options
-    #
-    # * +:device_list+ - an Array of Device to build the program for
-    # * +: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 link_program( input_programs, options = {}, &block)
-      return OpenCL.link_program(self, input_programs, options, &block)
-    end
-
     # Creates a Program from binary
     #
     # ==== Attributes
@@ -379,16 +300,6 @@ module OpenCL
        return OpenCL.create_program_with_binary(self, device_list, binaries)
     end
 
-    # Creates a Program from a list of built in kernel names
-    #
-    # ==== Attributes
-    #
-    # * +device_list+ - an Array of Device to create the program for
-    # * +kernel_names+ - a single or an Array of String representing the kernel names
-    def create_program_with_built_in_kernels( device_list, kernel_names )
-      return OpenCL.create_program_with_built_in_kernels(self, device_list, kernel_names )
-    end
-
     # Creates a Program from sources in the Context
     #
     # ==== Attributes
@@ -398,15 +309,6 @@ module OpenCL
       return OpenCL.create_program_with_source(self, strings)
     end
 
-    # Create a Program from an intermediate level representation in the Context
-    #
-    # ==== Attributes
-    #
-    # * +il+ - a binary string containing the intermediate level representation of the program
-    def create_program_with_il(il)
-      return OpenCL.create_program_with_il(self, il)
-    end
-
     # Creates a Sampler in the Context
     #
     # ==== Options
@@ -421,47 +323,145 @@ module OpenCL
       return OpenCL.create_sampler( self, options )
     end
 
-    # Creates a Pipe in the Context
-    #
-    # ==== Attributes
-    #
-    # * +pipe_packet_size+ - size of a packet in the Pipe
-    # * +pipe_max_packets+ - size of the Pipe in packet
-    #
-    # ==== Options
-    # 
-    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
-    def create_pipe( pipe_packet_size, pipe_max_packets, opts = {} )
-      return OpenCL.create_pipe( self, pipe_packet_size, pipe_max_packets, opts )
+    module OpenCL11
+      extend InnerGenerator
+
+      get_info("Context", :cl_uint, "num_devices")
+
+      # Creates a user Event in the Context
+      def create_user_event
+        return OpenCL.create_user_event(self)
+      end
+
     end
 
-    # Creates an SVMPointer pointing to an SVM area of memory in the Context
-    #
-    # ==== Attributes
-    #
-    # * +size+ - the size of the mmemory area to allocate
-    # * +options+ - a hash containing named options
-    #
-    # ==== Options
-    #
-    # * +:alignment+ - imposes the minimum alignment in byte
-    def svm_alloc(size, options = {})
-      return OpenCL.svm_alloc( self, size, options)
+
+    module OpenCL12
+
+      # Creates an Image in the Context from an OpenGL texture
+      #
+      # ==== Attributes
+      #
+      # * +texture_target+ - a :GLenum defining the image type of texture
+      # * +texture+ - a :GLuint specifying the name of the texture
+      # * +options+ - a hash containing named options
+      #
+      # ==== Options
+      #
+      # * +:miplevel+ - a :GLint specifying the mipmap level to be used (default 0)
+      # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image
+      def create_from_gl_texture( texture_target, texture, options = {} )
+        return OpenCL.create_from_gl_texture( self, texture_target, texture, options )
+      end
+      alias :create_from_GL_texture :create_from_gl_texture
+
+      # Creates an Image in the Context
+      #
+      # ==== Attributes
+      #
+      # * +format+ - an ImageFormat
+      # * +options+ - an ImageDesc
+      #
+      # ==== Options
+      # 
+      # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
+      # * +:host_ptr+ - if provided, the Pointer (or convertible to Pointer using to_ptr) to the memory area to use
+      def create_image( format, desc, options = {} )
+        return OpenCL.create_image( self, format, desc, options )
+      end
+
+      # Links a set of compiled programs for all device in the Context, or a subset of devices
+      #
+      # ==== Attributes
+      #
+      # * +input_programs+ - a single or an Array of Program
+      # * +options+ - a Hash containing named options
+      # * +block+ - if provided, a callback invoked when the Program is built. Signature of the callback is { |Program, Pointer to user_data| ... }
+      #
+      # ==== Options
+      #
+      # * +:device_list+ - an Array of Device to build the program for
+      # * +: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 link_program( input_programs, options = {}, &block)
+        return OpenCL.link_program(self, input_programs, options, &block)
+      end
+
+      # Creates a Program from a list of built in kernel names
+      #
+      # ==== Attributes
+      #
+      # * +device_list+ - an Array of Device to create the program for
+      # * +kernel_names+ - a single or an Array of String representing the kernel names
+      def create_program_with_built_in_kernels( device_list, kernel_names )
+        return OpenCL.create_program_with_built_in_kernels(self, device_list, kernel_names )
+      end
+
     end
 
-    # Frees an SVMPointer
-    #
-    # ==== Attributes
-    #
-    # * +svm_pointer+ - the SVMPointer to deallocate
-    def svm_free(svm_pointer)
-      return OpenCL.svm_free(self, svm_pointer)
+    module OpenCL20
+
+      # Creates a Pipe in the Context
+      #
+      # ==== Attributes
+      #
+      # * +pipe_packet_size+ - size of a packet in the Pipe
+      # * +pipe_max_packets+ - size of the Pipe in packet
+      #
+      # ==== Options
+      # 
+      # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
+      def create_pipe( pipe_packet_size, pipe_max_packets, opts = {} )
+        return OpenCL.create_pipe( self, pipe_packet_size, pipe_max_packets, opts )
+      end
+
+      # Creates an SVMPointer pointing to an SVM area of memory in the Context
+      #
+      # ==== Attributes
+      #
+      # * +size+ - the size of the mmemory area to allocate
+      # * +options+ - a hash containing named options
+      #
+      # ==== Options
+      #
+      # * +:alignment+ - imposes the minimum alignment in byte
+      def svm_alloc(size, options = {})
+        return OpenCL.svm_alloc( self, size, options)
+      end
+
+      # Frees an SVMPointer
+      #
+      # ==== Attributes
+      #
+      # * +svm_pointer+ - the SVMPointer to deallocate
+      def svm_free(svm_pointer)
+        return OpenCL.svm_free(self, svm_pointer)
+      end
+
     end
 
-    def set_default_device_command_queue( device, command_queue )
-      return OpenCL.set_default_device_command_queue( self, device, command_queue )
+    module OpenCL21
+
+      # Create a Program from an intermediate level representation in the Context
+      #
+      # ==== Attributes
+      #
+      # * +il+ - a binary string containing the intermediate level representation of the program
+      def create_program_with_il(il)
+        return OpenCL.create_program_with_il(self, il)
+      end
+
+      def set_default_device_command_queue( device, command_queue )
+        return OpenCL.set_default_device_command_queue( self, device, command_queue )
+      end
+
     end
 
+    register_extension( :v11, OpenCL11, "platform.version_number >= 1.1" )
+    register_extension( :v12, OpenCL12, "platform.version_number >= 1.2" )
+    register_extension( :v20, OpenCL20, "platform.version_number >= 2.0" )
+    register_extension( :v21, OpenCL21, "platform.version_number >= 2.1" )
+
   end
 
 end

data/lib/opencl_ruby_ffi/Device.rb

@@ -26,7 +26,7 @@ module OpenCL
     error = clCreateSubDevices( 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)
+      Device::new(device_ptr, false)
     }
   end
 
@@ -39,7 +39,7 @@ module OpenCL
     return [ device_timestamp_p.read_cl_ulong, host_timestamp_p.read_cl_ulong ]
   end
 
-  def self.get_device_and_host_timer( device )
+  def self.get_host_timer( device )
     error_check(INVALID_OPERATION) if device.platform.version_number < 2.1
     host_timestamp_p = MemoryPointer::new( :cl_ulong )
     error = clGetHostTimer( device, host_timestamp_p)
@@ -50,18 +50,18 @@ module OpenCL
   # Maps the cl_device_id object of OpenCL
   class Device
     include InnerInterface
-
-    class << self
-      include InnerGenerator
-    end
+    extend InnerGenerator
 
     def inspect
       return "#<#{self.class.name}: #{name} (#{pointer.to_i})>"
     end
 
-    #:stopdoc:
-    DRIVER_VERSION = 0x102D
-    #:startdoc:
+    get_info("Device", :cl_uint, "address_bits")
+    get_info("Device", :cl_bool, "available")
+    get_info("Device", :cl_bool, "compiler_available")
+    get_info("Device", :cl_bool, "endian_little")
+    get_info("Device", :cl_bool, "error_correction_support")
+    get_info("Device", :cl_device_exec_capabilities, "execution_capabilities")
 
     # Returns an Array of String corresponding to the Device extensions
     def extensions
@@ -75,49 +75,58 @@ module OpenCL
       return ext_string.split(" ")
     end
 
-    # Returns an Array of String corresponding to the Device built in kernel names
-    def built_in_kernels
-      built_in_kernels_size = MemoryPointer::new( :size_t )
-      error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS, 0, nil, built_in_kernels_size)
-      error_check(error)
-      ker = MemoryPointer::new( built_in_kernels_size.read_size_t )
-      error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS, built_in_kernels_size.read_size_t, ker, nil)
-      error_check(error)
-      ker_string = ker.read_string
-      return ker_string.split(";")
-    end
+    get_info("Device", :cl_ulong, "global_mem_cache_size")
+    get_info("Device", :cl_device_mem_cache_type, "global_mem_cache_type")
+    get_info("Device", :cl_uint,  "global_mem_cacheline_size")
+    get_info("Device", :cl_ulong, "global_mem_size")
+    get_info("Device", :cl_bool,  "image_support")
+    get_info("Device", :size_t,   "image2d_max_height")
+    get_info("Device", :size_t,   "image2d_max_width")
+    get_info("Device", :size_t,   "image3d_max_depth")
+    get_info("Device", :size_t,   "image3d_max_height")
+    get_info("Device", :size_t,   "image3d_max_width")
+    get_info("Device", :cl_ulong, "local_mem_size")
+    get_info("Device", :cl_device_local_mem_type, "local_mem_type")
+    get_info("Device", :cl_uint,  "max_clock_frequency")
+    get_info("Device", :cl_uint,  "max_compute_units")
+    get_info("Device", :cl_uint,  "max_constant_args")
+    get_info("Device", :cl_ulong, "max_constant_buffer_size")
+    get_info("Device", :cl_ulong, "max_mem_alloc_size")
+    get_info("Device", :size_t,   "max_parameter_size")
+    get_info("Device", :cl_uint,  "max_read_image_args")
+    get_info("Device", :cl_uint,  "max_samplers")
+    get_info("Device", :size_t,   "max_work_group_size")
+    get_info("Device", :cl_uint,  "max_work_item_dimensions")
+    get_info_array("Device", :size_t, "max_work_item_sizes")
+    get_info("Device", :cl_uint, "max_write_image_args")
+    get_info("Device", :cl_uint, "mem_base_addr_align")
+    get_info("Device", :cl_uint, "min_data_type_align_size")
+    get_info("Device", :string,  "name")
+
+    alias to_s name
 
-    # 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)
+    # Returns the Platform the Device belongs to
+    def platform
+      ptr = MemoryPointer::new( OpenCL::Platform )
+      error = OpenCL.clGetDeviceInfo(self, PLATFORM, OpenCL::Platform.size, ptr, 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
-
-    def il_version_number
-      return il_version.scan(/(\d+\.\d+)/).first.first.to_f
+      return OpenCL::Platform::new(ptr.read_pointer)
     end
 
-    %w( BUILT_IN_KERNELS DRIVER_VERSION VERSION VENDOR PROFILE OPENCL_C_VERSION NAME IL_VERSION ).each { |prop|
-      eval get_info("Device", :string, prop)
-    }
-
-    # returs a floating point number corresponding to the OpenCL C version of the Device
-    def opencl_c_version_number
-      ver = self.opencl_c_version
-      n = ver.scan(/OpenCL C (\d+\.\d+)/)
-      return n.first.first.to_f
-    end
+    get_info("Device", :cl_uint, "preferred_vector_width_char")
+    get_info("Device", :cl_uint, "preferred_vector_width_short")
+    get_info("Device", :cl_uint, "preferred_vector_width_int")
+    get_info("Device", :cl_uint, "preferred_vector_width_long")
+    get_info("Device", :cl_uint, "preferred_vector_width_float")
+    get_info("Device", :cl_uint, "preferred_vector_width_double")
+    get_info("Device", :string,  "profile")
+    get_info("Device", :size_t,  "profiling_timer_resolution")
+    get_info("Device", :cl_command_queue_properties, "queue_properties")
+    get_info("Device", :cl_device_fp_config,         "single_fp_config")
+    get_info("Device", :cl_device_type, "type")
+    get_info("Device", :string,         "vendor")
+    get_info("Device", :cl_uint,        "vendor_id")
+    get_info("Device", :string,         "version")
 
     # returs a floating point number corresponding to the OpenCL version of the Device
     def version_number
@@ -126,203 +135,240 @@ module OpenCL
       return n.first.first.to_f
     end
 
-    %w( MAX_MEM_ALLOC_SIZE MAX_CONSTANT_BUFFER_SIZE LOCAL_MEM_SIZE GLOBAL_MEM_CACHE_SIZE GLOBAL_MEM_SIZE ).each { |prop|
-      eval get_info("Device", :cl_ulong, prop)
-    }
-
-    %w( IMAGE_PITCH_ALIGNMENT IMAGE_BASE_ADDRESS_ALIGNMENT REFERENCE_COUNT PARTITION_MAX_SUB_DEVICES VENDOR_ID PREFERRED_VECTOR_WIDTH_HALF PREFERRED_VECTOR_WIDTH_CHAR PREFERRED_VECTOR_WIDTH_SHORT PREFERRED_VECTOR_WIDTH_INT PREFERRED_VECTOR_WIDTH_LONG PREFERRED_VECTOR_WIDTH_FLOAT PREFERRED_VECTOR_WIDTH_DOUBLE NATIVE_VECTOR_WIDTH_CHAR NATIVE_VECTOR_WIDTH_SHORT NATIVE_VECTOR_WIDTH_INT NATIVE_VECTOR_WIDTH_LONG NATIVE_VECTOR_WIDTH_FLOAT NATIVE_VECTOR_WIDTH_DOUBLE NATIVE_VECTOR_WIDTH_HALF MIN_DATA_TYPE_ALIGN_SIZE MEM_BASE_ADDR_ALIGN MAX_WRITE_IMAGE_ARGS MAX_READ_WRITE_IMAGE_ARGS MAX_WORK_ITEM_DIMENSIONS MAX_SAMPLERS MAX_READ_IMAGE_ARGS MAX_CONSTANT_ARGS MAX_COMPUTE_UNITS MAX_CLOCK_FREQUENCY ADDRESS_BITS GLOBAL_MEM_CACHELINE_SIZE QUEUE_ON_DEVICE_PREFERRED_SIZE QUEUE_ON_DEVICE_MAX_SIZE MAX_ON_DEVICE_QUEUES MAX_ON_DEVICE_EVENTS MAX_PIPE_ARGS PIPE_MAX_ACTIVE_RESERVATIONS PIPE_MAX_PACKET_SIZE PREFERRED_PLATFORM_ATOMIC_ALIGNMENT PREFERRED_GLOBAL_ATOMIC_ALIGNMENT PREFERRED_LOCAL_ATOMIC_ALIGNMENT MAX_NUM_SUB_GROUPS ).each { |prop|
-      eval get_info("Device", :cl_uint, prop)
-    }
-
-    %w( PRINTF_BUFFER_SIZE IMAGE_MAX_BUFFER_SIZE IMAGE_MAX_ARRAY_SIZE PROFILING_TIMER_RESOLUTION MAX_WORK_GROUP_SIZE MAX_PARAMETER_SIZE IMAGE2D_MAX_WIDTH IMAGE2D_MAX_HEIGHT IMAGE3D_MAX_WIDTH IMAGE3D_MAX_HEIGHT IMAGE3D_MAX_DEPTH MAX_GLOBAL_VARIABLE_SIZE GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE ).each { |prop|
-      eval get_info("Device", :size_t, prop)
-    }
-
-    %w( PREFERRED_INTEROP_USER_SYNC LINKER_AVAILABLE IMAGE_SUPPORT HOST_UNIFIED_MEMORY COMPILER_AVAILABLE AVAILABLE ENDIAN_LITTLE ERROR_CORRECTION_SUPPORT SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS ).each { |prop|
-      eval get_info("Device", :cl_bool, prop)
-    }
-
-    %w( SINGLE_FP_CONFIG HALF_FP_CONFIG DOUBLE_FP_CONFIG ).each { |prop|
-      eval get_info("Device", :cl_device_fp_config, prop)
-    }
+    get_info("Device", :string, "driver_version")
+
+    module OpenCL11
+      extend InnerGenerator
+
+      get_info("Device", :cl_bool, "host_unified_memory")
+      get_info("Device", :cl_uint, "native_vector_width_char")
+      get_info("Device", :cl_uint, "native_vector_width_short")
+      get_info("Device", :cl_uint, "native_vector_width_int")
+      get_info("Device", :cl_uint, "native_vector_width_long")
+      get_info("Device", :cl_uint, "native_vector_width_float")
+      get_info("Device", :cl_uint, "native_vector_width_double")
+      get_info("Device", :cl_uint, "native_vector_width_half")
+      get_info("Device", :string,  "opencl_c_version")
+
+      # returs a floating point number corresponding to the OpenCL C version of the Device
+      def opencl_c_version_number
+        ver = self.opencl_c_version
+        n = ver.scan(/OpenCL C (\d+\.\d+)/)
+        return n.first.first.to_f
+      end
 
-    ##
-    # :method: execution_capabilities()
-    # Returns an ExecCpabilities representing the execution capabilities corresponding to the Device
-    eval get_info("Device", :cl_device_exec_capabilities, "EXECUTION_CAPABILITIES")
-
-    ##
-    # :method: global_mem_cache_type()
-    # Returns a MemCacheType representing the type of the global cache memory on the Device
-    eval get_info("Device", :cl_device_mem_cache_type, "GLOBAL_MEM_CACHE_TYPE")
-
-    ##
-    # :method: local_mem_type()
-    # Returns a LocalMemType rpresenting the type of the local memory on the Device
-    eval get_info("Device", :cl_device_local_mem_type, "LOCAL_MEM_TYPE")
-
-    ##
-    # :method: queue_properties()
-    # Returns a CommandQueue::Properties representing the properties supported by a CommandQueue targetting the Device
-    eval get_info("Device", :cl_command_queue_properties, "QUEUE_PROPERTIES")
-
-    ##
-    # :method: queue_on_device_properties()
-    # Returns a CommandQueue::Properties representing the properties supported by a CommandQueue on the Device
-    eval get_info("Device", :cl_command_queue_properties, "QUEUE_ON_DEVICE_PROPERTIES")
-
-    ##
-    # :method: queue_on_host_properties()
-    # Returns a CommandQueue::Properties representing the properties supported by a CommandQueue targetting the Device
-    eval get_info("Device", :cl_command_queue_properties, "QUEUE_ON_HOST_PROPERTIES")
-
-    ##
-    # :method: type()
-    # Returns a Device::Type representing the type of the Device
-    eval get_info("Device", :cl_device_type, "TYPE")
-
-    ##
-    # :method: partition_affinity_domain()
-    # Returns an AffinityDomain representing the list of supported affinity domains for partitioning the Device using OpenCL::Device::PARTITION_BY_AFFINITY_DOMAIN
-    eval get_info("Device", :cl_device_affinity_domain, "PARTITION_AFFINITY_DOMAIN")
-
-    ##
-    # :method: max_work_item_sizes()
-    # Maximum number of work-items that can be specified in each dimension of the work-group to clEnqueueNDRangeKernel for the Device
-    eval get_info_array("Device", :size_t, "MAX_WORK_ITEM_SIZES")
-
-    ##
-    # :method: partition_properties()
-    # Returns the list of partition types supported by the Device
-    def partition_properties
-      ptr1 = MemoryPointer::new( :size_t, 1)
-      error = OpenCL.clGetDeviceInfo(self, PARTITION_PROPERTIES, 0, nil, ptr1)
-      error_check(error)
-      ptr2 = MemoryPointer::new( ptr1.read_size_t )
-      error = OpenCL.clGetDeviceInfo(self, PARTITION_PROPERTIES, ptr1.read_size_t, ptr2, nil)
-      error_check(error)
-      arr = ptr2.get_array_of_cl_device_partition_property(0, ptr1.read_size_t/ OpenCL.find_type(:cl_device_partition_property).size)
-      arr.reject! { |e| e.null? }
-      return arr.collect { |e| Partition::new(e.to_i) }
+      get_info("Device", :cl_uint, "preferred_vector_width_half")
+ 
     end
 
-    ##
-    # :method: svm_capabilities()
-    # Returns an SVMCapabilities representing the the SVM capabilities corresponding to the device
-    eval get_info_array("Device", :cl_device_svm_capabilities, "SVM_CAPABILITIES")
+    module OpenCL12
+      extend InnerGenerator
+
+      # Returns an Array of String corresponding to the Device built in kernel names
+      def built_in_kernels
+        built_in_kernels_size = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS, 0, nil, built_in_kernels_size)
+        error_check(error)
+        ker = MemoryPointer::new( built_in_kernels_size.read_size_t )
+        error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS, built_in_kernels_size.read_size_t, ker, nil)
+        error_check(error)
+        ker_string = ker.read_string
+        return ker_string.split(";")
+      end
 
-    # Return an Array of partition properties names representing the partition type supported by the device
-    def partition_properties_names
-      self.partition_properties.collect { |p| p.name }
-    end
+      get_info("Device", :size_t,  "image_max_buffer_size")
+      get_info("Device", :size_t,  "image_max_array_size")
+      get_info("Device", :cl_bool, "linker_available")
+
+      # Returns the parent Device if it exists
+      def parent_device
+        ptr = MemoryPointer::new( Device )
+        error = OpenCL.clGetDeviceInfo(self, PARENT_DEVICE, Device.size, ptr, nil)
+        error_check(error)
+        return nil if ptr.null?
+        return Device::new(ptr.read_pointer)
+      end
 
-    ##
-    # :method: partition_type()
-    # Returns a list of :cl_device_partition_property used to create the Device
-    def partition_type
-      ptr1 = MemoryPointer::new( :size_t, 1)
-      error = OpenCL.clGetDeviceInfo(self, PARTITION_TYPE, 0, nil, ptr1)
-      error_check(error)
-      ptr2 = MemoryPointer::new( ptr1.read_size_t )
-      error = OpenCL.clGetDeviceInfo(self, PARTITION_TYPE, ptr1.read_size_t, ptr2, nil)
-      error_check(error)
-      arr = ptr2.get_array_of_cl_device_partition_property(0, ptr1.read_size_t/ OpenCL.find_type(:cl_device_partition_property).size)
-      if arr.first.to_i == Partition::BY_NAMES_EXT then
+      get_info("Device", :cl_uint, "partition_max_sub_devices")
+
+      ##
+      # @!method partition_properties()
+      # Returns the list of partition types supported by the Device
+      def partition_properties
+        ptr1 = MemoryPointer::new( :size_t, 1)
+        error = OpenCL.clGetDeviceInfo(self, PARTITION_PROPERTIES, 0, nil, ptr1)
+        error_check(error)
+        ptr2 = MemoryPointer::new( ptr1.read_size_t )
+        error = OpenCL.clGetDeviceInfo(self, PARTITION_PROPERTIES, ptr1.read_size_t, ptr2, nil)
+        error_check(error)
+        arr = ptr2.get_array_of_cl_device_partition_property(0, ptr1.read_size_t/ OpenCL.find_type(:cl_device_partition_property).size)
+        arr.reject! { |e| e.null? }
+        return arr.collect { |e| Partition::new(e.to_i) }
+      end
+
+      get_info("Device", :cl_device_affinity_domain, "partition_affinity_domain")
+
+      ##
+      # @!method partition_type()
+      # Returns a list of :cl_device_partition_property used to create the Device
+      def partition_type
+        ptr1 = MemoryPointer::new( :size_t, 1)
+        error = OpenCL.clGetDeviceInfo(self, PARTITION_TYPE, 0, nil, ptr1)
+        error_check(error)
+        ptr2 = MemoryPointer::new( ptr1.read_size_t )
+        error = OpenCL.clGetDeviceInfo(self, PARTITION_TYPE, ptr1.read_size_t, ptr2, nil)
+        error_check(error)
+        arr = ptr2.get_array_of_cl_device_partition_property(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(Partition::new(arr.first.to_i))
-        i = 1
-        return arr_2 if arr.length <= i
-        while arr[i].to_i - (0x1 << Pointer.size * 8) != Partition::BY_NAMES_LIST_END_EXT do
-          arr_2[i] = arr[i].to_i
-          i += 1
-          return arr_2 if arr.length <= i
+        arr_2.push( Partition::new(ptype) )
+        return arr_2 if arr.length == 1
+        case ptype
+        when Partition::BY_NAMES_EXT
+          i = 1
+          while arr[i].to_i - (0x1 << Pointer.size * 8) != Partition::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( Partition::new(Partition::BY_NAMES_LIST_END_EXT) )
+          arr_2.push( 0 )
+        when Partition::EQUALLY
+          arr_2.push(arr[1].to_i)
+          arr_2.push( 0 )
+        when Partition::BY_COUNTS
+          i = 1
+          while arr[i].to_i != Partition::BY_COUNTS_LIST_END do
+            arr_2.push( arr[i].to_i )
+            i += 1
+            return arr_2 if arr.length <= i
+          end
+          arr_2.push( Partition::new(Partition::BY_COUNTS_LIST_END) )
+          arr_2.push( 0 )
         end
-        arr_2[i] = Partition::new(Partition::BY_NAMES_LIST_END_EXT)
-        arr_2[i+1] = 0
         return arr_2
-      else
-        return arr.collect { |e| Partition::new(e.to_i) }
       end
-    end
-    #eval get_info_array("Device", :cl_device_partition_property, "PARTITION_TYPE")
 
-    # Returns the Platform the Device belongs to
-    def platform
-      ptr = MemoryPointer::new( OpenCL::Platform )
-      error = OpenCL.clGetDeviceInfo(self, PLATFORM, OpenCL::Platform.size, ptr, nil)
-      error_check(error)
-      return OpenCL::Platform::new(ptr.read_pointer)
-    end
+      get_info("Device", :size_t,  "printf_buffer_size")
+      get_info("Device", :cl_bool, "preferred_interop_user_sync")
+      get_info("Device", :cl_uint, "reference_count")
+      #undef_method :min_data_type_align_size
+
+      # Partitions the Device in serveral sub-devices
+      #
+      # ==== Attributes
+      # 
+      # * +properties+ - an Array of :cl_device_partition_property
+      #
+      # ==== Returns
+      #
+      # an Array of Device
+      def create_sub_devices( properties )
+        return OpenCL.create_sub_devices( self, properties )
+      end
 
-    # Returns the parent Device if it exists
-    def parent_device
-      ptr = MemoryPointer::new( Device )
-      error = OpenCL.clGetDeviceInfo(self, PARENT_DEVICE, Device.size, ptr, nil)
-      error_check(error)
-      return nil if ptr.null?
-      return Device::new(ptr.read_pointer)
-    end
+      # Partitions the Device in serveral sub-devices by affinity domain
+      #
+      # ==== Attributes
+      # 
+      # * +affinity_domain+ - the :cl_device_partition_property specifying the target affinity domain
+      #
+      # ==== Returns
+      #
+      # an Array of Device
+      def partition_by_affinity_domain( affinity_domain = AFFINITY_DOMAIN_NEXT_PARTITIONABLE )
+        return OpenCL.create_sub_devices( self,  [ PARTITION_BY_AFFINITY_DOMAIN, affinity_domain ] )
+      end
 
-    # Partitions the Device in serveral sub-devices
-    #
-    # ==== Attributes
-    # 
-    # * +properties+ - an Array of :cl_device_partition_property
-    #
-    # ==== Returns
-    #
-    # an Array of Device
-    def create_sub_devices( properties )
-      return OpenCL.create_sub_devices( self, properties )
-    end
+      # Partitions the Device in serveral sub-devices containing compute_unit_number compute units
+      #
+      # ==== Attributes
+      # 
+      # * +compute_unit_number+ - the number of compute units in each sub-device
+      #
+      # ==== Returns
+      #
+      # an Array of Device
+      def partition_equally( compute_unit_number = 1 )
+        return OpenCL.create_sub_devices( self,  [ PARTITION_EQUALLY, compute_unit_number ] )
+      end
 
-    # Partitions the Device in serveral sub-devices by affinity domain
-    #
-    # ==== Attributes
-    # 
-    # * +affinity_domain+ - the :cl_device_partition_property specifying the target affinity domain
-    #
-    # ==== Returns
-    #
-    # an Array of Device
-    def partition_by_affinity_domain( affinity_domain = AFFINITY_DOMAIN_NEXT_PARTITIONABLE )
-      return OpenCL.create_sub_devices( self,  [ PARTITION_BY_AFFINITY_DOMAIN, affinity_domain ] )
-    end
+      # Partitions the Device in serveral sub-devices each containing a specific number of compute units
+      #
+      # ==== Attributes
+      # 
+      # * +compute_unit_count_list+ - an Array of compute unit counts
+      #
+      # ==== Returns
+      #
+      # an Array of Device
+      def partition_by_counts( *compute_unit_count_list )
+        compute_unit_count_list = [1] if compute_unit_count_list == []
+        compute_unit_count_list.flatten!
+        return OpenCL.create_sub_devices( self,  [ PARTITION_BY_COUNTS] + compute_unit_count_list + [ PARTITION_BY_COUNTS_LIST_END ] )
+      end
 
-    # Partitions the Device in serveral sub-devices containing compute_unit_number compute units
-    #
-    # ==== Attributes
-    # 
-    # * +compute_unit_number+ - the number of compute units in each sub-device
-    #
-    # ==== Returns
-    #
-    # an Array of Device
-    def partition_equally( compute_unit_number = 1 )
-      return OpenCL.create_sub_devices( self,  [ PARTITION_EQUALLY, compute_unit_number ] )
-    end
+      def partition_by_names_intel( *compute_unit_name_list )
+        compute_unit_name_list = [0] if compute_unit_name_list == []
+        compute_unit_name_list.flatten!
+        return OpenCL.create_sub_devices( self,  [ Partition::BY_NAMES_INTEL ] + compute_unit_name_list + [ Partition::BY_NAMES_LIST_END_INTEL ] )
+      end
 
-    # Partitions the Device in serveral sub-devices each containing a specific number of compute units
-    #
-    # ==== Attributes
-    # 
-    # * +compute_unit_number_list+ - an Array of compute unit number
-    #
-    # ==== Returns
-    #
-    # an Array of Device
-    def partition_by_count( compute_unit_number_list = [1] )
-      return OpenCL.create_sub_devices( self,  [ PARTITION_BY_COUNTS] + compute_unit_number_list + [ PARTITION_BY_COUNTS_LIST_END ] )
     end
 
-    def get_device_and_host_timer
-      return OpenCL.get_device_and_host_timer( self )
+
+    module OpenCL20
+      extend InnerGenerator
+
+      get_info("Device", :size_t,  "global_variable_preferred_total_size")
+      get_info("Device", :cl_uint, "image_base_address_alignment")
+      get_info("Device", :cl_uint, "image_pitch_alignment")
+      get_info("Device", :cl_uint, "max_on_device_events")
+      get_info("Device", :cl_uint, "max_on_device_queues")
+      get_info("Device", :cl_uint, "max_pipe_args")
+      get_info("Device", :cl_uint, "max_read_image_args")
+      get_info("Device", :cl_uint, "max_read_write_image_args")
+      get_info("Device", :cl_uint, "pipe_max_active_reservations")
+      get_info("Device", :cl_uint, "pipe_max_packet_size")
+      get_info("Device", :cl_uint, "preferred_global_atomic_alignment")
+      get_info("Device", :cl_uint, "preferred_local_atomic_alignment")
+      get_info("Device", :cl_uint, "preferred_platform_atomic_alignment")
+      get_info("Device", :cl_uint, "queue_on_device_max_size")
+      get_info("Device", :cl_uint, "queue_on_device_preferred_size")
+      get_info("Device", :cl_command_queue_properties, "queue_on_device_properties")
+      get_info("Device", :cl_command_queue_properties, "queue_on_host_properties")
+      get_info_array("Device", :cl_device_svm_capabilities, "svm_capabilities")
+
     end
 
-    def get_host_timer
-      return OpenCL.get_host_timer( self )
+    module OpenCL21
+      extend InnerGenerator
+
+      get_info("Device", :string, "il_version")
+
+      def il_version_number
+        return il_version.scan(/(\d+\.\d+)/).first.first.to_f
+      end
+
+      get_info_array("Device", :cl_uint, "max_num_sub_groups")
+      get_info_array("Device", :cl_bool, "subgroup_independent_forward_progress")
+
+      def get_device_and_host_timer
+        return OpenCL.get_device_and_host_timer( self )
+      end
+
+      def get_host_timer
+        return OpenCL.get_host_timer( self )
+      end
+
     end
 
+    register_extension( :v11,  OpenCL11, "platform.version_number >= 1.1" )
+    register_extension( :v12,  OpenCL12, "platform.version_number >= 1.2" )
+    register_extension( :v20,  OpenCL20, "platform.version_number >= 2.0" )
+    register_extension( :v21,  OpenCL21, "platform.version_number >= 2.1" )
+
   end
 
 end