opencl_ruby_ffi 1.2.2 → 1.3.0

data/lib/opencl_ruby_ffi/Event.rb

@@ -69,10 +69,7 @@ module OpenCL
   # Maps the cl_event object
   class Event
     include InnerInterface
-
-    class << self
-      include InnerGenerator
-    end
+    extend InnerGenerator
 
     def inspect
       return "#<#{self.class.name}: #{command_type}>"
@@ -91,17 +88,12 @@ module OpenCL
       end
     end
 
-    # Returns the Context associated with the Event
+    get_info("Event", :cl_command_type, "command_type")
+
     def context
-      ptr = MemoryPointer::new( Context )
-      error = OpenCL.clGetEventInfo(self, CONTEXT, Context.size, ptr, nil)
-      error_check(error)
-      return Context::new( ptr.read_pointer )
+      return command_queue.context
     end
 
-    # Returns a CommandType corresponding to the type of the command associated with the Event
-    eval get_info("Event", :cl_command_type, "COMMAND_TYPE")
-
     # Returns a CommandExecutionStatus corresponding to the status of the command associtated with the Event
     def command_execution_status
       ptr = MemoryPointer::new( :cl_int )
@@ -110,10 +102,7 @@ module OpenCL
       return CommandExecutionStatus::new( ptr.read_cl_int )
     end
 
-    ##
-    # :method: reference_count()
-    # Returns the reference counter of th Event
-    eval get_info("Event", :cl_uint, "REFERENCE_COUNT")
+    get_info("Event", :cl_uint, "reference_count")
 
     # Returns the date the command corresponding to Event was queued
     def profiling_command_queued
@@ -147,29 +136,44 @@ module OpenCL
        return ptr.read_cl_ulong
     end
 
-    # Sets the satus of Event (a user event) to the given execution status
-    def set_user_event_status( execution_status )
-      return OpenCL.set_user_event_status( self, execution_status )
-    end
+    module OpenCL11
+
+      # Returns the Context associated with the Event
+      def context
+        ptr = MemoryPointer::new( Context )
+        error = OpenCL.clGetEventInfo(self, CONTEXT, Context.size, ptr, nil)
+        error_check(error)
+        return Context::new( ptr.read_pointer )
+      end
+
+      # Sets the satus of Event (a user event) to the given execution status
+      def set_user_event_status( execution_status )
+        return OpenCL.set_user_event_status( self, execution_status )
+      end
+
+      alias :set_status :set_user_event_status
+
+      # Attaches a callback to the Event that will be called on the given transition
+      #
+      # ==== Attributes
+      #
+      # * +command_exec_callback_type+ - a CommandExecutionStatus
+      # * +options+ - a hash containing named options
+      # * +block+ - a callback invoked when the given Event occurs. Signature of the callback is { |Event, :cl_int event_command_exec_status, Pointer to user_data| ... }
+      #
+      # ==== Options
+      #
+      # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
+      def set_event_callback( command_exec_callback_type, options={}, &proc )
+        return OpenCL.set_event_callback( self, command_exec_callback_type, options, &proc )
+      end
+
+      alias :set_callback :set_event_callback
 
-    alias :set_status :set_user_event_status
-
-    # Attaches a callback to the Event that will be called on the given transition
-    #
-    # ==== Attributes
-    #
-    # * +command_exec_callback_type+ - a CommandExecutionStatus
-    # * +options+ - a hash containing named options
-    # * +block+ - a callback invoked when the given Event occurs. Signature of the callback is { |Event, :cl_int event_command_exec_status, Pointer to user_data| ... }
-    #
-    # ==== Options
-    #
-    # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
-    def set_event_callback( command_exec_callback_type, options={}, &proc )
-      return OpenCL.set_event_callback( self, command_exec_callback_type, options, &proc )
     end
 
-    alias :set_callback :set_event_callback
+    register_extension( :v11, OpenCL11, "cond = false; if command_queue then cond = (command_queue.device.platform.version_number >= 1.1) else ptr = MemoryPointer::new( Context ); error = OpenCL.clGetEventInfo(self, CONTEXT, Context.size, ptr, nil); error_check(error); cond = (Context::new( ptr.read_pointer ).platform.version_number >= 1.1) end; cond" )
 
   end
+
 end

data/lib/opencl_ruby_ffi/Image.rb

@@ -122,15 +122,15 @@ module OpenCL
   # ==== Options
   #
   # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image
-  def self.create_from_gl_render_buffer( context, renderbuffer, options = {} )
+  def self.create_from_gl_renderbuffer( context, renderbuffer, options = {} )
     flags = get_flags( options )
     error = MemoryPointer::new( :cl_int )
-    img = clCreateFromGLRenderBuffer( context, flags, renderbuffer, error )
+    img = clCreateFromGLRenderbuffer( context, flags, renderbuffer, error )
     error_check(error.read_cl_int)
     return Image::new( img, false )
   end
   class << self
-    alias :create_from_GL_render_buffer :create_from_gl_render_buffer
+    alias :create_from_GL_renderbuffer :create_from_gl_renderbuffer
   end
 
   # Creates an Image from an OpenGL texture
@@ -228,53 +228,6 @@ module OpenCL
       return "#<#{self.class.name}: #{format.channel_order}, #{format.channel_data_type}, #{width}#{h != 0 ? "x#{h}" : ""}#{d != 0 ? "x#{d}" : ""} (#{size})#{f.to_i != 0 ? " (#{f})" : "" }>"
     end
 
-    ##
-    # :method: element_size
-    # Returns the element_size of the Image
-
-    ##
-    # :method: row_pitch
-    # Returns the row_pitch of the Image
-
-    ##
-    # :method: slice_pitch
-    # Returns the slice_pitch of the Image
-
-    ##
-    # :method: width
-    # Returns the width of the Image
-
-    ##
-    # :method: height
-    # Returns the height of the Image
-
-    ##
-    # :method: depth
-    # Returns the depth of the Image
-
-    ##
-    # :method: array_size
-    # Returns the array_size of the Image
-    %w( ELEMENT_SIZE ROW_PITCH SLICE_PITCH WIDTH HEIGHT DEPTH ARRAY_SIZE ).each { |prop|
-      eval get_info("Image", :size_t, prop)
-    }
-
-    ##
-    # :method: num_mip_levels
-    # Returns the num_mip_levels of the Image
-
-    ##
-    # :method: num_samples
-    # Returns the num_samples of the Image
-    %w( NUM_MIP_LEVELS NUM_SAMPLES ).each { |prop|
-      eval get_info("Image", :cl_uint, prop)
-    }
-
-    # Returns the ImageDesc corresponding to the Image
-    def desc
-      return ImageDesc::new( self.type, self.width, self.height, self.depth, self.array_size, self.row_pitch, self.slice_pitch, self.num_mip_levels, self.num_samples, self.buffer )
-    end
-
     # Returns the ImageFormat corresponding to the image
     def format
       image_format = MemoryPointer::new( ImageFormat )
@@ -283,15 +236,39 @@ module OpenCL
       return ImageFormat::new( image_format )
     end
 
-    # Returns the associated Buffer if any, nil otherwise
-    def buffer
-      ptr = MemoryPointer::new( Buffer )
-      error = OpenCL.clGetImageInfo(self,  BUFFER, Buffer.size, ptr, nil)
-      error_check(error)
-      return nil if ptr.null?
-      return Buffer::new(ptr.read_pointer)
+    get_info("Image", :size_t, "element_size")
+    get_info("Image", :size_t, "row_pitch")
+    get_info("Image", :size_t, "slice_pitch")
+    get_info("Image", :size_t, "width")
+    get_info("Image", :size_t, "height")
+    get_info("Image", :size_t, "depth")
+
+    module OpenCL12
+      extend InnerGenerator
+
+      get_info("Image", :size_t, "array_size")
+
+      # Returns the associated Buffer if any, nil otherwise
+      def buffer
+        ptr = MemoryPointer::new( Buffer )
+        error = OpenCL.clGetImageInfo(self,  BUFFER, Buffer.size, ptr, nil)
+        error_check(error)
+        return nil if ptr.null?
+        return Buffer::new(ptr.read_pointer)
+      end
+
+      get_info("Image", :cl_uint, "num_mip_levels")
+      get_info("Image", :cl_uint, "num_samples")
+
+      # Returns the ImageDesc corresponding to the Image
+      def desc
+        return ImageDesc::new( self.type, self.width, self.height, self.depth, self.array_size, self.row_pitch, self.slice_pitch, self.num_mip_levels, self.num_samples, self.buffer )
+      end
+
     end
 
+    register_extension( :v12, OpenCL12, "platform.version_number >= 1.2" )
+
   end
 
 end

data/lib/opencl_ruby_ffi/Kernel.rb

@@ -47,10 +47,7 @@ module OpenCL
   # Maps the cl_kernel object
   class Kernel
     include InnerInterface
-
-    class << self
-      include InnerGenerator
-    end
+    extend InnerGenerator
 
     def inspect
       return "#<#{self.class.name}: #{name}>"
@@ -59,72 +56,43 @@ module OpenCL
     # Maps the logical cl arg object
     class Arg
       include InnerInterface
- 
-      class << self
-        include InnerGenerator
-      end
+      extend InnerGenerator
+
       # Returns the index of the Arg in the list
       attr_reader :index
       # Returns the Kernel this Arg belongs to
       attr_reader :kernel
 
-      # Creates a new arg for a Kernel at index
-      def initialize( kernel, index )
-        @index = index
-        @kernel = kernel
-      end
+      if ExtendedStruct::const_get(:FORCE_EXTENSIONS_LOADING) then
 
-      # Returns an AddressQualifier corresponding to the Arg
-      def address_qualifier
-        error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
-        ptr = MemoryPointer::new( :cl_kernel_arg_address_qualifier )
-        error = OpenCL.clGetKernelArgInfo(@kernel, @index, ADDRESS_QUALIFIER, ptr.size, ptr, nil)
-        error_check(error)
-        return AddressQualifier::new( ptr.read_cl_kernel_arg_address_qualifier )
-      end
+        def self.register_extension(name, mod, cond)
+          include mod
+        end
 
-      # Returns an AccessQualifier corresponding to the Arg
-      def access_qualifier
-        error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
-        ptr = MemoryPointer::new( :cl_kernel_arg_access_qualifier )
-        error = OpenCL.clGetKernelArgInfo(@kernel, @index, ACCESS_QUALIFIER, ptr.size, ptr, nil)
-        error_check(error)
-        return AccessQualifier::new( ptr.read_cl_kernel_arg_access_qualifier )
-      end
+        # Creates a new arg for a Kernel at index
+        def initialize( kernel, index )
+          @index = index
+          @kernel = kernel
+        end
 
-      # Returns a TypeQualifier corresponding to the Arg
-      def type_qualifier
-        error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
-        ptr = MemoryPointer::new( :cl_kernel_arg_type_qualifier )
-        error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_QUALIFIER, ptr.size, ptr, nil)
-        error_check(error)
-        return TypeQualifier::new( ptr.read_cl_kernel_arg_type_qualifier )
-      end
+      else
 
-      # Returns a String corresponding to the Arg type name
-      def type_name
-        error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
-        ptr1 = MemoryPointer::new( :size_t, 1)
-        error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_NAME, 0, nil, ptr1)
-        error_check(error)
-        ptr2 = MemoryPointer::new( ptr1.read_size_t )
-        error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_NAME, ptr1.read_size_t, ptr2, nil)
-        error_check(error)
-        return ptr2.read_string
-      end
+        Extensions = {}
 
-      # Returns a String corresponding to the Arg name
-      def name
-        error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
-        ptr1 = MemoryPointer::new( :size_t, 1)
-        error = OpenCL.clGetKernelArgInfo(@kernel, @index, NAME, 0, nil, ptr1)
-        error_check(error)
-        ptr2 = MemoryPointer::new( ptr1.read_size_t )
-        error = OpenCL.clGetKernelArgInfo(@kernel, @index, NAME, ptr1.read_size_t, ptr2, nil)
-        error_check(error)
-        return ptr2.read_string
-      end
+        def self.register_extension(name, mod, cond)
+          Extensions[name] = [mod, cond]
+        end
 
+        # Creates a new arg for a Kernel at index
+        def initialize( kernel, index )
+          @index = index
+          @kernel = kernel
+          Extensions.each { |name, ext|
+            extend ext[0] if eval(ext[1])
+          }
+        end
+
+      end
       # Sets this Arg to value. The size of value can be specified.
       def set(value, size = nil)
         if value.class == SVMPointer and @kernel.context.platform.version_number >= 2.0 then
@@ -134,6 +102,65 @@ module OpenCL
         end
       end
 
+      module OpenCL12
+
+        # Returns an AddressQualifier corresponding to the Arg
+        def address_qualifier
+          error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
+          ptr = MemoryPointer::new( :cl_kernel_arg_address_qualifier )
+          error = OpenCL.clGetKernelArgInfo(@kernel, @index, ADDRESS_QUALIFIER, ptr.size, ptr, nil)
+          error_check(error)
+          return AddressQualifier::new( ptr.read_cl_kernel_arg_address_qualifier )
+        end
+
+        # Returns an AccessQualifier corresponding to the Arg
+        def access_qualifier
+          error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
+          ptr = MemoryPointer::new( :cl_kernel_arg_access_qualifier )
+          error = OpenCL.clGetKernelArgInfo(@kernel, @index, ACCESS_QUALIFIER, ptr.size, ptr, nil)
+          error_check(error)
+          return AccessQualifier::new( ptr.read_cl_kernel_arg_access_qualifier )
+        end
+
+        # Returns a String corresponding to the Arg type name
+        def type_name
+          error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
+          ptr1 = MemoryPointer::new( :size_t, 1)
+          error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_NAME, 0, nil, ptr1)
+          error_check(error)
+          ptr2 = MemoryPointer::new( ptr1.read_size_t )
+          error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_NAME, ptr1.read_size_t, ptr2, nil)
+          error_check(error)
+          return ptr2.read_string
+        end
+
+        # Returns a TypeQualifier corresponding to the Arg
+        def type_qualifier
+          error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
+          ptr = MemoryPointer::new( :cl_kernel_arg_type_qualifier )
+          error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_QUALIFIER, ptr.size, ptr, nil)
+          error_check(error)
+          return TypeQualifier::new( ptr.read_cl_kernel_arg_type_qualifier )
+        end
+
+        # Returns a String corresponding to the Arg name
+        def name
+          error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
+          ptr1 = MemoryPointer::new( :size_t, 1)
+          error = OpenCL.clGetKernelArgInfo(@kernel, @index, NAME, 0, nil, ptr1)
+          error_check(error)
+          ptr2 = MemoryPointer::new( ptr1.read_size_t )
+          error = OpenCL.clGetKernelArgInfo(@kernel, @index, NAME, ptr1.read_size_t, ptr2, nil)
+          error_check(error)
+          return ptr2.read_string
+        end
+
+        alias to_s name
+
+      end
+
+      register_extension( :v12, OpenCL12, "kernel.context.platform.version_number >= 1.2" )
+
     end
 
     # Returns an Array of Arg corresponding to the arguments of the Kernel
@@ -146,52 +173,12 @@ module OpenCL
       return a
     end
 
-    # Specifies the list of SVM pointers the kernel will be using
-    def set_svm_ptrs( ptrs )
-      error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.0
-      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_SVM_PTRS, pt.size, pt)
-      error_check(error)
-      return self
-    end
-
-    # Specifies the granularity of the SVM system.
-    def set_svm_fine_grain_system( flag )
-      error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.0
-      pt = MemoryPointer::new(  :cl_bool )
-      pt.write_cl_bool( flag )
-      error = OpenCL.clSetKernelExecInfo( self, EXEC_INFO_SVM_FINE_GRAIN_SYSTEM, pt.size, pt)
-      error_check(error)
-      return self
-    end
-
-    ##
-    # :method: function_name()
-    # returns a String correspondig to the Kernel function name
-
-    ##
-    # :method: attributes()
-    # returns a String containing the attributes qualifier used at kernel definition
-    %w( FUNCTION_NAME ATTRIBUTES ).each { |prop|
-      eval get_info("Kernel", :string, prop)
-    }
-
+    get_info("Kernel", :string, "function_name")
     alias name function_name
+    alias to_s name
 
-    ##
-    # :method: num_args()
-    # Returns the number of arguments for the Kernel
-
-    ##
-    # :method: reference_count
-    # Returns the reference counter for the Kernel
-    %w( NUM_ARGS REFERENCE_COUNT ).each { |prop|
-      eval get_info("Kernel", :cl_uint, prop)
-    }
+    get_info("Kernel", :cl_uint, "num_args")
+    get_info("Kernel", :cl_uint, "reference_count")
 
     # Returns the Context the Kernel is associated with
     def context
@@ -230,92 +217,11 @@ module OpenCL
       return ptr.read_cl_ulong
     end
 
-    def preferred_work_group_size_multiple(device = program.devices.first)
-      ptr = MemoryPointer::new( :size_t )
-      error = OpenCL.clGetKernelWorkGroupInfo(self, device, PREFERRED_WORK_GROUP_SIZE_MULTIPLE, ptr.size, ptr, nil)
-      error_check(error)
-      return ptr.read_size_t
-    end
-
-    def private_mem_size(device = program.devices.first)
-      ptr = MemoryPointer::new( :cl_ulong )
-      error = OpenCL.clGetKernelWorkGroupInfo(self, device, PRIVATE_MEM_SIZE, ptr.size, ptr, nil)
-      error_check(error)
-      return ptr.read_cl_ulong
-    end
-
-    def global_work_size(device = program.devices.first)
-      ptr = MemoryPointer::new( :size_t, 3 )
-      error = OpenCL.clGetKernelWorkGroupInfo(self, device, GLOBAL_WORK_SIZE, ptr.size, ptr, nil)
-      error_check(error)
-      return ptr.get_array_of_size_t(0,3)
-    end
-
-    def max_num_sub_groups(device = program.devices.first)
-      error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.1
-      ptr = MemoryPointer::new( :size_t )
-      error = OpenCL.clGetKernelSubGroupInfo(self, device, MAX_NUM_SUB_GROUPS, 0, nil, ptr.size, ptr, nil)
-      error_check(error)
-      return ptr.read_size_t
-    end
-
-    def compile_num_sub_groups(device = program.devices.first)
-      error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.1
-      ptr = MemoryPointer::new( :size_t )
-      error = OpenCL.clGetKernelSubGroupInfo(self, device, COMPILE_NUM_SUB_GROUPS, 0, nil, ptr.size, ptr, nil)
-      error_check(error)
-      return ptr.read_size_t
-    end
-
-    def max_sub_group_size_for_ndrange(local_work_size, device = program.devices.first)
-      error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.1
-      local_work_size = [local_work_size].flatten
-      lws_p = MemoryPointer::new( :size_t, local_work_size.length )
-      local_work_size.each_with_index { |e,i|
-        lws_p[i].write_size_t( e )
-      }
-      ptr = MemoryPointer::new( :size_t )
-      error = OpenCL.clGetKernelSubGroupInfo(self, device, MAX_SUB_GROUP_SIZE_FOR_NDRANGE, lws_p.size, lws_p, ptr.size, ptr, nil)
-      error_check(error)
-      return ptr.read_size_t
-    end
-
-    def sub_groups_count_for_ndrange(local_work_size, device = program.devices.first)
-      error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.1
-      local_work_size = [local_work_size].flatten
-      lws_p = MemoryPointer::new( :size_t, local_work_size.length )
-      local_work_size.each_with_index { |e,i|
-        lws_p[i].write_size_t( e )
-      }
-      ptr = MemoryPointer::new( :size_t )
-      error = OpenCL.clGetKernelSubGroupInfo(self, device, SUB_GROUP_COUNT_FOR_NDRANGE, lws_p.size, lws_p, ptr.size, ptr, nil)
-      error_check(error)
-      return ptr.read_size_t
-    end
-
-    def local_size_for_sub_group_count(sub_group_number, device = program.devices.first)
-      error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.1
-      sgp_p = MemoryPointer::new( :size_t )
-      sgp_p.write_size_t(sub_group_number)
-      size_ptr = MemoryPointer::new( :size_t )
-      error = OpenCL.clGetKernelSubGroupInfo(self, device, LOCAL_SIZE_FOR_SUB_GROUP_COUNT, sgp_p.size, sgp_p, 0, nil, size_ptr)
-      error_check(error)
-      lws_p = MemoryPointer::new( size_ptr.read_size_t )
-      error = OpenCL.clGetKernelSubGroupInfo(self, device, LOCAL_SIZE_FOR_SUB_GROUP_COUNT, sgp_p.size, sgp_p, lws_p.size, lws_p, nil)
-      error_check(error)
-      return lws_p.get_array_of_size_t(0, lws_p.size/size_ptr.size)
-    end
-
     # Set the index th argument of the Kernel to value. The size of value can be specified.
     def set_arg(index, value, size = nil)
       OpenCL.set_kernel_arg(self, index, value, size)
     end
 
-    # Set the index th argument of the Kernel to an svm pointer value.
-    def set_arg_svm_pointer(index, svm_pointer)
-      OpenCL.set_kernel_arg_svm_pointer(self, index, svm_pointer)
-    end
-
     # Enqueues the Kernel in the given queue, specifying the global_work_size. Arguments for the kernel are specified afterwards. Last, a hash containing options for enqueu_ndrange kernel can be specified
     def enqueue_with_args(command_queue, global_work_size, *args)
       n = self.num_args
@@ -327,19 +233,173 @@ module OpenCL
         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])
-        else
-          self.set_arg(i, args[i])
-        end
+        self.set_arg(i, args[i])
       }
       command_queue.enqueue_ndrange_kernel(self, global_work_size, options)
     end
 
-    def clone
-      return OpenCL.clone_kernel( self )
+    module OpenCL11
+
+      def preferred_work_group_size_multiple(device = program.devices.first)
+        ptr = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetKernelWorkGroupInfo(self, device, PREFERRED_WORK_GROUP_SIZE_MULTIPLE, ptr.size, ptr, nil)
+        error_check(error)
+        return ptr.read_size_t
+      end
+
+      def private_mem_size(device = program.devices.first)
+        ptr = MemoryPointer::new( :cl_ulong )
+        error = OpenCL.clGetKernelWorkGroupInfo(self, device, PRIVATE_MEM_SIZE, ptr.size, ptr, nil)
+        error_check(error)
+        return ptr.read_cl_ulong
+      end
+
+    end
+
+    module OpenCL12
+
+      ##
+      # returns a String containing the attributes qualifier used at kernel definition
+      def attributes
+        attributes_size = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetKernelInfo( self, ATTRIBUTES, 0, nil, attributes_size)
+        error_check(error)
+        attr = MemoryPointer::new( attributes_size.read_size_t )
+        error = OpenCL.clGetKernelInfo( self, ATTRIBUTES, attributes_size.read_size_t, attr, nil)
+        error_check(error)
+        attr_string = attr.read_string
+        return attr_string.split(" ")
+      end
+
+      def global_work_size(device = program.devices.first)
+        ptr = MemoryPointer::new( :size_t, 3 )
+        error = OpenCL.clGetKernelWorkGroupInfo(self, device, GLOBAL_WORK_SIZE, ptr.size, ptr, nil)
+        error_check(error)
+        return ptr.get_array_of_size_t(0,3)
+      end
+
+    end
+
+    module OpenCL20
+
+      # Specifies the list of SVM pointers the kernel will be using
+      def set_svm_ptrs( ptrs )
+        error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.0
+        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_SVM_PTRS, pt.size, pt)
+        error_check(error)
+        return self
+      end
+
+      # Specifies the granularity of the SVM system.
+      def set_svm_fine_grain_system( flag )
+        error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.0
+        pt = MemoryPointer::new(  :cl_bool )
+        pt.write_cl_bool( flag )
+        error = OpenCL.clSetKernelExecInfo( self, EXEC_INFO_SVM_FINE_GRAIN_SYSTEM, pt.size, pt)
+        error_check(error)
+        return self
+      end
+
+      # Set the index th argument of the Kernel to an svm pointer value.
+      def set_arg_svm_pointer(index, svm_pointer)
+        OpenCL.set_kernel_arg_svm_pointer(self, index, svm_pointer)
+      end
+
+      # Enqueues the Kernel in the given queue, specifying the global_work_size. Arguments for the kernel are specified afterwards. Last, a hash containing options for enqueu_ndrange kernel can be specified
+      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])
+          else
+            self.set_arg(i, args[i])
+          end
+        }
+        command_queue.enqueue_ndrange_kernel(self, global_work_size, options)
+      end
+
     end
 
+    module OpenCL21
+
+      def max_num_sub_groups(device = program.devices.first)
+        error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.1
+        ptr = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetKernelSubGroupInfo(self, device, MAX_NUM_SUB_GROUPS, 0, nil, ptr.size, ptr, nil)
+        error_check(error)
+        return ptr.read_size_t
+      end
+
+      def compile_num_sub_groups(device = program.devices.first)
+        error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.1
+        ptr = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetKernelSubGroupInfo(self, device, COMPILE_NUM_SUB_GROUPS, 0, nil, ptr.size, ptr, nil)
+        error_check(error)
+        return ptr.read_size_t
+      end
+
+      def max_sub_group_size_for_ndrange(local_work_size, device = program.devices.first)
+        error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.1
+        local_work_size = [local_work_size].flatten
+        lws_p = MemoryPointer::new( :size_t, local_work_size.length )
+        local_work_size.each_with_index { |e,i|
+          lws_p[i].write_size_t( e )
+        }
+        ptr = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetKernelSubGroupInfo(self, device, MAX_SUB_GROUP_SIZE_FOR_NDRANGE, lws_p.size, lws_p, ptr.size, ptr, nil)
+        error_check(error)
+        return ptr.read_size_t
+      end
+
+      def sub_groups_count_for_ndrange(local_work_size, device = program.devices.first)
+        error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.1
+        local_work_size = [local_work_size].flatten
+        lws_p = MemoryPointer::new( :size_t, local_work_size.length )
+        local_work_size.each_with_index { |e,i|
+          lws_p[i].write_size_t( e )
+        }
+        ptr = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetKernelSubGroupInfo(self, device, SUB_GROUP_COUNT_FOR_NDRANGE, lws_p.size, lws_p, ptr.size, ptr, nil)
+        error_check(error)
+        return ptr.read_size_t
+      end
+
+      def local_size_for_sub_group_count(sub_group_number, device = program.devices.first)
+        error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.1
+        sgp_p = MemoryPointer::new( :size_t )
+        sgp_p.write_size_t(sub_group_number)
+        size_ptr = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetKernelSubGroupInfo(self, device, LOCAL_SIZE_FOR_SUB_GROUP_COUNT, sgp_p.size, sgp_p, 0, nil, size_ptr)
+        error_check(error)
+        lws_p = MemoryPointer::new( size_ptr.read_size_t )
+        error = OpenCL.clGetKernelSubGroupInfo(self, device, LOCAL_SIZE_FOR_SUB_GROUP_COUNT, sgp_p.size, sgp_p, lws_p.size, lws_p, nil)
+        error_check(error)
+        return lws_p.get_array_of_size_t(0, lws_p.size/size_ptr.size)
+      end
+
+      def clone
+        return OpenCL.clone_kernel( self )
+      end
+
+    end
+
+    register_extension( :v11, OpenCL11, "context.platform.version_number >= 1.1" )
+    register_extension( :v12, OpenCL12, "context.platform.version_number >= 1.2" )
+    register_extension( :v20, OpenCL20, "context.platform.version_number >= 2.0" )
+    register_extension( :v21, OpenCL21, "context.platform.version_number >= 2.1" )
+
   end
 
 end