opencl_ruby_ffi 0.1

data/lib/opencl_ruby_ffi/Event.rb

@@ -0,0 +1,152 @@
+module OpenCL
+
+  
+  # Attaches a callback to event that will be called on the given transition
+  #
+  # ==== Attributes
+  #
+  # * +event+ - the Event to attach the callback to
+  # * +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, FFI::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 self.set_event_callback( event, command_exec_callback_type, options = {}, &proc )
+    OpenCL.error_check(OpenCL::INVALID_OPERATION) if event.context.platform.version_number < 1.1
+    error = OpenCL.clSetEventCallback( event, command_exec_callback_type, proc, options[:user_data] )
+    OpenCL.error_check(error)
+    return self
+  end
+
+  # Creates a user Event
+  #
+  # ==== Attributes
+  #
+  # * +context+ - Context the created Event will be associated to
+  def self.create_user_event(context)
+    OpenCL.error_check(OpenCL::INVALID_OPERATION) if context.platform.version_number < 1.1
+    error = FFI::MemoryPointer::new(:cl_int)
+    event = OpenCL.clCreateUserEvent(context, error)
+    OpenCL.error_check(error.read_cl_int)
+    return Event::new(event, false)
+  end
+
+  # Sets the satus of user Event to the given execution status
+  def self.set_user_event_status( event, execution_status )
+    OpenCL.error_check(OpenCL::INVALID_OPERATION) if event.context.platform.version_number < 1.1
+    error = OpenCL.clSetUserEventStatus( event, execution_status )
+    OpenCL.error_check(error)
+    return self
+  end
+
+  # Creates an event from a GL sync object
+  #
+  # ==== Attributes
+  #
+  # * +context+ - Context the created Event will be associated to
+  # * +sync+ - a :GLsync representing the name of the sync object
+  def self.create_event_from_GL_sync_KHR( context, sync )
+    error = FFI::MemoryPointer::new(:cl_int)
+    event = OpenCL.clCreateEventFromGLsyncKHR(context, sync, error)
+    OpenCL.error_check(error.read_cl_int)
+    return Event::new(event, false)
+  end
+
+  # Maps the cl_event object
+  class Event
+
+    # Returns the CommandQueue associated with the Event, if it exists
+    def command_queue
+      ptr = FFI::MemoryPointer.new( CommandQueue )
+      error = OpenCL.clGetEventInfo(self, Event::COMMAND_QUEUE, CommandQueue.size, ptr, nil)
+      OpenCL.error_check(error)
+      pt = ptr.read_pointer
+      if pt.null? then
+        return nil
+      else
+        return OpenCL::CommandQueue::new( pt )
+      end
+    end
+
+    # Returns the Context associated with the Event
+    def context
+      ptr = FFI::MemoryPointer.new( Context )
+      error = OpenCL.clGetEventInfo(self, Event::CONTEXT, Context.size, ptr, nil)
+      OpenCL.error_check(error)
+      return OpenCL::Context::new( ptr.read_pointer )
+    end
+
+    # Returns a CommandType corresponding to the type of the command associated with the Event
+    eval OpenCL.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 = FFI::MemoryPointer.new( :cl_int )
+      error = OpenCL.clGetEventInfo(self, OpenCL::Event::COMMAND_EXECUTION_STATUS, ptr.size, ptr, nil )
+      OpenCL.error_check(error)
+      return OpenCL::CommandExecutionStatus::new( ptr.read_cl_int )
+    end
+
+    ##
+    # :method: reference_count()
+    # Returns the reference counter of th Event
+    eval OpenCL.get_info("Event", :cl_uint, "REFERENCE_COUNT")
+
+    # Returns the date the command corresponding to Event was queued
+    def profiling_command_queued
+       ptr = FFI::MemoryPointer.new( :cl_ulong )
+       error = OpenCL.clGetEventProfilingInfo(self, OpenCL::PROFILING_COMMAND_QUEUED, ptr.size, ptr, nil )
+       OpenCL.error_check(error)
+       return ptr.read_cl_ulong
+    end
+
+    # Returns the date the command corresponding to Event was submited
+    def profiling_command_submit
+       ptr = FFI::MemoryPointer.new( :cl_ulong )
+       error = OpenCL.clGetEventProfilingInfo(self, OpenCL::PROFILING_COMMAND_SUBMIT, ptr.size, ptr, nil )
+       OpenCL.error_check(error)
+       return ptr.read_cl_ulong
+    end
+
+    # Returns the date the command corresponding to Event started
+    def profiling_command_start
+       ptr = FFI::MemoryPointer.new( :cl_ulong )
+       error = OpenCL.clGetEventProfilingInfo(self, OpenCL::PROFILING_COMMAND_START, ptr.size, ptr, nil )
+       OpenCL.error_check(error)
+       return ptr.read_cl_ulong
+    end
+
+    # Returns the date the command corresponding to Event ended
+    def profiling_command_end
+       ptr = FFI::MemoryPointer.new( :cl_ulong )
+       error = OpenCL.clGetEventProfilingInfo(self, OpenCL::PROFILING_COMMAND_END, ptr.size, ptr, nil )
+       OpenCL.error_check(error)
+       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
+
+    alias :set_status :set_user_event_status
+
+    # Attaches a callback to the Event that will be called on the given transition
+    #
+    # ==== Attributes
+    #
+    # * +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, FFI::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
+
+  end
+end

data/lib/opencl_ruby_ffi/Image.rb

@@ -0,0 +1,270 @@
+module OpenCL
+
+  # Creates an Image
+  #
+  # ==== Attributes
+  #
+  # * +context+ - Context the created Image will be associated to
+  # * +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 self.create_image( context, format, desc, options = {} )
+    flags = OpenCL.get_flags( options )
+    host_ptr = options[:host_ptr]
+    error = FFI::MemoryPointer.new( :cl_int )
+    img_ptr = OpenCL.clCreateImage( context, flags, format, desc, host_ptr, error )
+    OpenCL.error_check(error.read_cl_int)
+    return Image::new(img_ptr, false)
+  end
+
+  # Creates a 1D Image
+  #
+  # ==== Attributes
+  #
+  # * +context+ - Context the created Image will be associated to
+  # * +format+ - an ImageFormat
+  # * +width+ - width of the image
+  #
+  # ==== 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 self.create_image_1D( context, format, width, options )
+    if context.platform.version_number > 1.1 then
+      desc = OpenCL::ImageDesc::new(OpenCL::Mem::IMAGE1D, width, 0, 0, 0, 0, 0, 0, 0, nil)
+      return OpenCL.create_image( context, format, desc, options )
+    else
+      OpenCL.error_check(OpenCL::Error::INVALID_OPERATION)
+    end
+  end
+
+  # Creates a 2D Image
+  #
+  # ==== Attributes
+  #
+  # * +context+ - Context the created Image will be associated to
+  # * +format+ - an ImageFormat
+  # * +width+ - width of the image
+  #
+  # ==== 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
+  # * +:row_pitch+ - if provided the row_pitch of data in host_ptr
+  def self.create_image_2D( context, format, width, height, options = {} )
+    row_pitch = 0
+    row_pitch = options[:row_pitch] if options[:row_pitch]
+    if context.platform.version_number > 1.1 then
+      desc = OpenCL::ImageDesc::new(OpenCL::Mem::IMAGE2D, width, height, 0, 0, row_pitch, 0, 0, 0, nil)
+      return OpenCL.create_image( context, format, desc, options )
+    end
+    flags = OpenCL.get_flags( options )
+    host_ptr = options[:host_ptr]
+    error = FFI::MemoryPointer.new( :cl_int )
+    img_ptr = OpenCL.clCreateImage2D( context, flags, format, width, heigh, row_pitch, host_ptr, error )
+    OpenCL.error_check(error.read_cl_int)
+    return Image::new(img_ptr, false)
+  end
+
+  # Creates a 3D Image
+  #
+  # ==== Attributes
+  #
+  # * +context+ - Context the created Image will be associated to
+  # * +format+ - an ImageFormat
+  # * +width+ - width of the image
+  #
+  # ==== 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
+  # * +:row_pitch+ - if provided the row_pitch of data in host_ptr
+  # * +:slice_pitch+ - if provided the slice_pitch of data in host_ptr
+  def self.create_image_3D( context, format, width, height, depth, options = {} )
+    row_pitch = 0
+    row_pitch = options[:row_pitch] if options[:row_pitch]
+    slice_pitch = 0
+    slice_pitch = options[:slice_pitch] if options[:slice_pitch]
+    if context.platform.version_number > 1.1 then
+      desc = OpenCL::ImageDesc::new(OpenCL::Mem::IMAGE3D, width, height, depth, 0, row_pitch, slice_pitch, 0, 0, nil)
+      return OpenCL.create_image( context, format, desc, flags, data )
+    end
+    flags = OpenCL.get_flags( options )
+    host_ptr = options[:host_ptr]
+    error = FFI::MemoryPointer.new( :cl_int )
+    img_ptr = OpenCL.clCreateImage3D( context, fs, format, width, heigh, depth, row_pitch, slice_pitch, d, error )
+    OpenCL.error_check(error.read_cl_int)
+    return Image::new(img_ptr, false)
+  end
+
+  # Creates an Image from an OpenGL render buffer
+  #
+  # ==== Attributes
+  #
+  # * +context+ - Context the created Image will be associated to
+  # * +renderbuf+ - opengl render buffer
+  # * +options+ - a hash containing named options
+  #
+  # ==== Options
+  #
+  # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image (default OpenCL::Mem::READ_WRITE)
+  def self.create_from_GL_render_buffer( context, renderbuffer, options = {} )
+    flags = OpenCL.get_flags( options )
+    error = FFI::MemoryPointer.new( :cl_int )
+    img = OpenCL.clCreateFromGLRenderBuffer( context, flags, renderbuffer, error )
+    OpenCL.error_check(error.read_cl_int)
+    return Image::new( img, false )
+  end
+
+  # Creates an Image from an OpenGL texture
+  #
+  # ==== Attributes
+  #
+  # * +context+ - Context the created Image will be associated to
+  # * +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 (default OpenCL::Mem::READ_WRITE)
+  def self.create_from_GL_texture( context, texture_target, texture, options = {} )
+    if context.platform.version_number < 1.2 then
+      OpenCL.error_check(OpenCL::INVALID_OPERATION)
+    end
+    flags = OpenCL.get_flags( options )
+    miplevel = 0
+    miplevel =  options[:miplevel] if options[:miplevel]
+    error = FFI::MemoryPointer.new( :cl_int )
+    img = OpenCL.clCreateFromGLTexture( context, flags, texture_target, miplevel, texture, error )
+    OpenCL.error_check(error.read_cl_int)
+    return Image::new( img, false )
+  end
+
+  # Creates an Image from an OpenGL 2D 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 self.create_from_GL_texture_2D( context, texture_target, texture, options = {} )
+    if context.platform.version_number > 1.1 then
+      return OpenCL.create_from_GL_texture( context, texture_target, texture, options )
+    end
+    flags = OpenCL.get_flags( options )
+    miplevel = 0
+    miplevel =  options[:miplevel] if options[:miplevel]
+    error = FFI::MemoryPointer.new( :cl_int )
+    img = OpenCL.clCreateFromGLTexture2D( context, flags, texture_target, miplevel, texture, error )
+    OpenCL.error_check(error.read_cl_int)
+    return Image::new( img, false )
+  end
+
+  # Creates an Image from an OpenGL 3D 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 self.create_from_GL_texture_3D( context, texture_target, texture, options = {} )
+    if context.platform.version_number > 1.1 then
+      return OpenCL.create_from_GL_texture( context, texture_target, texture, options )
+    end
+    flags = OpenCL.get_flags( options )
+    miplevel = 0
+    miplevel =  options[:miplevel] if options[:miplevel]
+    error = FFI::MemoryPointer.new( :cl_int )
+    img = OpenCL.clCreateFromGLTexture3D( context, flags, texture_target, miplevel, texture, error )
+    OpenCL.error_check(error.read_cl_int)
+    return Image::new( img, false )
+  end
+
+  # Maps the cl_mem OpenCL objects of type CL_MEM_OBJECT_IMAGE*
+  class Image
+
+
+    ##
+    # :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 OpenCL.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 OpenCL.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 = FFI::MemoryPointer.new( ImageFormat )
+      error = OpenCL.clGetImageInfo( self, OpenCL::Image::FORMAT, image_format.size, image_format, nil)
+      OpenCL.error_check(error)
+      return OpenCL::ImageFormat::from_pointer( image_format )
+    end
+
+    # Returns the associated Buffer if any, nil otherwise
+    def buffer
+      ptr = FFI::MemoryPointer.new( OpenCL::Buffer )
+      error = OpenCL.clGetImageInfo(self,  OpenCL::Image::BUFFER, OpenCL::Buffer.size, ptr, nil)
+      OpenCL.error_check(error)
+      return nil if ptr.null?
+      return OpenCL::Buffer::new(ptr.read_pointer)
+    end
+
+  end
+
+end
+

data/lib/opencl_ruby_ffi/Kernel.rb

@@ -0,0 +1,183 @@
+module OpenCL
+
+  # Creates an Array of Kernel corresponding to the kernels defined inside the Program
+  def self.create_kernels_in_program( program )
+    num_ptr = FFI::MemoryPointer.new( :cl_uint )
+    error = OpenCL. clCreateKernelsInProgram( program, 0, nil, num_ptr )
+    OpenCL.error_check(error)
+    num_kernels = num_ptr.read_cl_uint
+    kernels_ptr = FFI::MemoryPointer.new( OpenCL::Kernel, num_kernels )
+    error = OpenCL. clCreateKernelsInProgram( program, num_kernels, kernels_ptr, 0 )
+    OpenCL.error_check(error)
+    return kernels_ptr.get_array_of_pointer(0, num_kernels).collect { |kernel_ptr|
+      OpenCL::Kernel.new(kernel_ptr, false)
+    }
+  end
+
+  # Returns the Kernel corresponding the the specified name in the given Program
+  def self.create_kernel(program, name)
+    pointer_err = FFI::MemoryPointer.new( :cl_int )
+    kernel_ptr = OpenCL.clCreateKernel(program, name, pointer_err)
+    OpenCL.error_check(pointer_err.read_cl_int)
+    return OpenCL::Kernel::new( kernel_ptr, false )
+  end
+
+  # Set the index th argument of Kernel to value. size of value can be specified
+  def self.set_kernel_arg( kernel, index, value, size = nil )
+    sz = size
+    sz = value.class.size if sz == nil
+    val = value
+    if value.kind_of?(OpenCL::Mem) then
+      val = FFI::MemoryPointer.new( OpenCL::Mem )
+      val.write_pointer(value.to_ptr)
+    end
+    error = OpenCL.clSetKernelArg( kernel, index, sz, val )
+    OpenCL.error_check(error)
+  end
+
+  # Maps the cl_kernel object
+  class Kernel
+
+    # Maps the logical cl arg object
+    class Arg
+      # 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
+
+      # Returns an AddressQualifier corresponding to the Arg
+      def address_qualifier
+        OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
+        ptr = FFI::MemoryPointer.new( :cl_kernel_arg_address_qualifier )
+        error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::ADDRESS_QUALIFIER, ptr.size, ptr, nil)
+        OpenCL.error_check(error)
+        return OpenCL::Kernel::Arg::AddressQualifier::new( ptr.read_cl_kernel_arg_address_qualifier )
+      end
+
+      # Returns an AccessQualifier corresponding to the Arg
+      def access_qualifier
+        OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
+        ptr = FFI::MemoryPointer.new( :cl_kernel_arg_access_qualifier )
+        error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::ACCESS_QUALIFIER, ptr.size, ptr, nil)
+        OpenCL.error_check(error)
+        return OpenCL::Kernel::Arg::AccessQualifier::new( ptr.read_cl_kernel_arg_access_qualifier )
+      end
+
+      # Returns a TypeQualifier corresponding to the Arg
+      def type_qualifier
+        OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
+        ptr = FFI::MemoryPointer.new( :cl_kernel_arg_type_qualifier )
+        error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::TYPE_QUALIFIER, ptr.size, ptr, nil)
+        OpenCL.error_check(error)
+        return OpenCL::Kernel::Arg::TypeQualifier::new( ptr.read_cl_kernel_arg_type_qualifier )
+      end
+
+      # Returns a String corresponding to the Arg type name
+      def type_name
+        OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
+        ptr1 = FFI::MemoryPointer.new( :size_t, 1)
+        error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::TYPE_NAME, 0, nil, ptr1)
+        OpenCL.error_check(error)
+        ptr2 = FFI::MemoryPointer.new( ptr1.read_size_t )
+        error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::TYPE_NAME, ptr1.read_size_t, ptr2, nil)
+        OpenCL.error_check(error)
+        return ptr2.read_string
+      end
+
+      # Returns a String corresponding to the Arg name
+      def name
+        OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
+        ptr1 = FFI::MemoryPointer.new( :size_t, 1)
+        error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::NAME, 0, nil, ptr1)
+        OpenCL.error_check(error)
+        ptr2 = FFI::MemoryPointer.new( ptr1.read_size_t )
+        error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::NAME, ptr1.read_size_t, ptr2, nil)
+        OpenCL.error_check(error)
+        return ptr2.read_string
+      end
+
+      # Sets this Arg to value. The size of value can be specified.
+      def set(value, size = nil)
+        OpenCL.set_kernel_arg(@kernel, @index, value, size)
+      end
+
+    end
+
+    # Returns an Array of Arg corresponding to the arguments of the Kernel
+    def args
+      n = self.num_args
+      a = []
+      n.times { |i|
+        a.push OpenCL::Kernel::Arg::new(self, i)
+      }
+      return a
+    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 OpenCL.get_info("Kernel", :string, prop)
+    }
+
+    ##
+    # :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 OpenCL.get_info("Kernel", :cl_uint, prop)
+    }
+
+    # Returns the Context the Kernel is associated with
+    def context
+      ptr = FFI::MemoryPointer.new( Context )
+      error = OpenCL.clGetKernelInfo(self, Kernel::CONTEXT, Context.size, ptr, nil)
+      OpenCL.error_check(error)
+      return OpenCL::Context::new( ptr.read_pointer )
+    end
+
+    # Returns the Program the Kernel was created from
+    def program
+      ptr = FFI::MemoryPointer.new( Program )
+      error = OpenCL.clGetKernelInfo(self, Kernel::PROGRAM, Program.size, ptr, nil)
+      OpenCL.error_check(error)
+      return OpenCL::Program::new(ptr.read_pointer)
+    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
+
+    # 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 enqueuNDrange kernel can be specified
+    def enqueue_with_args(command_queue, global_work_size, *args)
+      n = self.num_args
+      OpenCL.error_check(OpenCL::INVALID_KERNEL_ARGS) if args.length < n
+      OpenCL.error_check(OpenCL::INVALID_KERNEL_ARGS) if args.length > n + 1
+      if args.length == n + 1
+        options = args.last
+      else
+        options = {}
+      end
+      n.times { |i|
+        self.set_arg(i, args[i])
+      }
+      command_queue.enqueue_NDrange_kernel(self, global_work_size, options)
+    end
+
+  end
+
+end