opencl_ruby_ffi 0.3 → 0.4

data/lib/opencl_ruby_ffi/Buffer.rb

@@ -36,7 +36,7 @@ module OpenCL
   def self.create_sub_buffer( buffer, type, info, options = {} )
     OpenCL.error_check(OpenCL::INVALID_OPERATION) if buffer.platform.version_number < 1.1
     flags = OpenCL.get_flags( options )
-    error = FFI::MemoryPointer.new( :cl_int )
+    error = FFI::MemoryPointer::new( :cl_int )
     buff = OpenCL.clCreateSubBuffer( buffer, flags, type, info, error)
     OpenCL.error_check(error.read_cl_int)
     return Buffer::new( buff, false )
@@ -55,7 +55,7 @@ module OpenCL
   # * +: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_buffer( context, bufobj, options = {} )
     flags = OpenCL.get_flags( options )
-    error = FFI::MemoryPointer.new( :cl_int )
+    error = FFI::MemoryPointer::new( :cl_int )
     buff = OpenCL.clCreateFromGLBuffer( context, flags, bufobj, error )
     OpenCL.error_check(error.read_cl_int)
     return Buffer::new( buff, false )

data/lib/opencl_ruby_ffi/CommandQueue.rb

@@ -11,6 +11,17 @@ module OpenCL
     return command_queue
   end
 
+  # Issues all the commands in a CommandQueue to the Device
+  #
+  # ==== Attributes
+  #
+  # * +command_queue+ - the CommandQueue to flush
+  def self.flush( command_queue )
+    error = OpenCL.clFlush( command_queue )
+    OpenCL.error_check( error )
+    return command_queue
+  end
+
   # Creates a CommandQueue targeting the specified Device
   #
   # ==== Attributes
@@ -24,7 +35,7 @@ module OpenCL
   # * +:properties+ - a single or an Array of :cl_command_queue_properties
   def self.create_command_queue( context, device, options = {} )
     properties = OpenCL.get_command_queue_properties( options )
-    error = FFI::MemoryPointer.new( :cl_int )
+    error = FFI::MemoryPointer::new( :cl_int )
     cmd = OpenCL.clCreateCommandQueue( context, device, properties, error )
     OpenCL.error_check(error.read_cl_int)
     return CommandQueue::new(cmd, false)
@@ -51,14 +62,14 @@ module OpenCL
     num_mem_objects = [mem_objects].flatten.length
     mem_list = nil
     if num_mem_objects > 0 then
-      mem_list = FFI::MemoryPointer.new( OpenCL::Mem, num_mem_objects )
+      mem_list = FFI::MemoryPointer::new( OpenCL::Mem, num_mem_objects )
       [mem_objects].flatten.each_with_index { |e, i|
         mem_list[i].write_pointer(e)
       }
     end
     flags = OpenCL.get_flags( options )
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueMigrateMemObjects( command_queue, num_mem_objects, mem_list, flags, num_events, events, event )
     OpenCL.error_check( error )
     return OpenCL::Event::new( event.read_ptr, false )
@@ -95,10 +106,10 @@ module OpenCL
     origin, region = OpenCL.get_origin_region( image, options, :origin, :region )
 
     num_events, events = OpenCL.get_event_wait_list( options )
-    image_row_pitch = FFI::MemoryPointer.new( :size_t )
-    image_slice_pitch = FFI::MemoryPointer.new( :size_t )
-    event = FFI::MemoryPointer.new( Event )
-    error = FFI::MemoryPointer.new( :cl_int )
+    image_row_pitch = FFI::MemoryPointer::new( :size_t )
+    image_slice_pitch = FFI::MemoryPointer::new( :size_t )
+    event = FFI::MemoryPointer::new( Event )
+    error = FFI::MemoryPointer::new( :cl_int )
     OpenCL.clEnqueueMapImage( command_queue, image, blocking, map_flags, origin, region, image_row_pitch, image_slice_pitch, num_events, events, event, error )
     OpenCL.error_check( error.read_cl_int )
     ev = OpenCL::Event::new( event.read_ptr, false )
@@ -135,8 +146,8 @@ module OpenCL
     size = buffer.size - offset
     size = options[:size] - offset if options[:size]
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
-    error = FFI::MemoryPointer.new( :cl_int )
+    event = FFI::MemoryPointer::new( Event )
+    error = FFI::MemoryPointer::new( :cl_int )
     ptr = OpenCL.clEnqueueMapBuffer( command_queue, buffer, blocking, map_flags, offset, size, num_events, events, error )
     OpenCL.error_check( error.read_cl_int )
     ev = OpenCL::Event::new( event.read_ptr, false )
@@ -161,7 +172,7 @@ module OpenCL
   # the Event associated with the command
   def self.enqueue_unmap_mem_object( command_queue, mem_obj, mapped_ptr, options = {} )
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueUnmapMemObject( command_queue, mem_obj, mapped_ptr, num_events, events, event )
     OpenCL.error_check( error )
     return OpenCL::Event::new( event.read_ptr, false )
@@ -197,7 +208,7 @@ module OpenCL
     blocking = OpenCL::FALSE
     blocking = OpenCL::TRUE if options[:blocking] or options[:blocking_read]
 
-    buffer_origin = FFI::MemoryPointer.new( :size_t, 3 )
+    buffer_origin = FFI::MemoryPointer::new( :size_t, 3 )
     (0..2).each { |i| buffer_origin[i].write_size_t(0) }
     bo = options[:src_origin] ? options[:src_origin] : options[:buffer_origin]
     if bo then
@@ -206,7 +217,7 @@ module OpenCL
       }
     end
 
-    host_origin = FFI::MemoryPointer.new( :size_t, 3 )
+    host_origin = FFI::MemoryPointer::new( :size_t, 3 )
     (0..2).each { |i| host_origin[i].write_size_t(0) }
     ho = options[:dst_origin] ? options[:dst_origin] : options[:host_origin]
     if ho then
@@ -215,7 +226,7 @@ module OpenCL
       }
     end
 
-    r = FFI::MemoryPointer.new( :size_t, 3 )
+    r = FFI::MemoryPointer::new( :size_t, 3 )
     (0..2).each { |i| r[i].write_size_t(0) }
     region[0..3].each_with_index { |e, i|
       r[i].write_size_t(e)
@@ -238,7 +249,7 @@ module OpenCL
       host_slice_pitch = 0
     end
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueReadBufferRect(command_queue, buffer, blocking, buffer_origin, host_origin, r, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events, events, event)
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -274,7 +285,7 @@ module OpenCL
     blocking = OpenCL::FALSE
     blocking = OpenCL::TRUE if options[:blocking] or options[:blocking_write]
 
-    buffer_origin = FFI::MemoryPointer.new( :size_t, 3 )
+    buffer_origin = FFI::MemoryPointer::new( :size_t, 3 )
     (0..2).each { |i| buffer_origin[i].write_size_t(0) }
     bo = options[:dst_origin] ? options[:dst_origin] : options[:buffer_origin]
     if bo then
@@ -283,7 +294,7 @@ module OpenCL
       }
     end
 
-    host_origin = FFI::MemoryPointer.new( :size_t, 3 )
+    host_origin = FFI::MemoryPointer::new( :size_t, 3 )
     (0..2).each { |i| host_origin[i].write_size_t(0) }
     ho = options[:src_origin] ? options[:src_origin] : options[:host_origin]
     if ho then
@@ -292,7 +303,7 @@ module OpenCL
       }
     end
 
-    r = FFI::MemoryPointer.new( :size_t, 3 )
+    r = FFI::MemoryPointer::new( :size_t, 3 )
     (0..2).each { |i| r[i].write_size_t(0) }
     region[0..3].each_with_index { |e, i|
       r[i].write_size_t(e)
@@ -315,7 +326,7 @@ module OpenCL
       host_slice_pitch = 0
     end
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueWriteBufferRect(command_queue, buffer, blocking, buffer_origin, host_origin, r, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events, events, event)
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -347,7 +358,7 @@ module OpenCL
   def self.enqueue_copy_buffer_rect(command_queue, src_buffer, dst_buffer, region, options = {})
     OpenCL.error_check(OpenCL::INVALID_OPERATION) if command_queue.context.platform.version_number < 1.1
 
-    src_origin = FFI::MemoryPointer.new( :size_t, 3 )
+    src_origin = FFI::MemoryPointer::new( :size_t, 3 )
     (0..2).each { |i| src_origin[i].write_size_t(0) }
     if options[:src_origin] then
       options[:src_origin].each_with_index { |e, i|
@@ -355,7 +366,7 @@ module OpenCL
       }
     end
 
-    dst_origin = FFI::MemoryPointer.new( :size_t, 3 )
+    dst_origin = FFI::MemoryPointer::new( :size_t, 3 )
     (0..2).each { |i| dst_origin[i].write_size_t(0) }
     if options[:dst_origin] then
       options[:dst_origin].each_with_index { |e, i|
@@ -363,7 +374,7 @@ module OpenCL
       }
     end
 
-    r = FFI::MemoryPointer.new( :size_t, 3 )
+    r = FFI::MemoryPointer::new( :size_t, 3 )
     (0..2).each { |i| r[i].write_size_t(0) }
     region[0..3].each_with_index { |e, i|
       r[i].write_size_t(e)
@@ -386,7 +397,7 @@ module OpenCL
       dst_slice_pitch = 0
     end
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueCopyBufferRect(command_queue, src_buffer, dst_buffer, src_origin, dst_origin, r, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events, events, event)
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -419,7 +430,7 @@ module OpenCL
     size = [ src_buffer.size - src_offset, dst_buffer.size - dst_offset ].min
     size = options[:size] if options[:size]
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueCopyBuffer(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events, events, event)
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -454,7 +465,7 @@ module OpenCL
     size = buffer.size - offset
     size = options[:size] if options[:size]
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueWriteBuffer(command_queue, buffer, blocking, offset, size, ptr, num_events, events, event)
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -488,7 +499,7 @@ module OpenCL
     size = buffer.size - offset
     size = options[:size] if options[:size]
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueReadBuffer(command_queue, buffer, blocking, offset, size, ptr, num_events, events, event)
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -513,13 +524,13 @@ module OpenCL
     num_objs = [mem_objects].flatten.length
     objs = nil
     if num_objs > 0 then
-      objs = FFI::MemoryPointer.new(  Mem, num_objs )
+      objs = FFI::MemoryPointer::new(  Mem, num_objs )
       [mem_objects].flatten.each_with_index { |o, i|
         objs[i].write_pointer(e)
       }
     end
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueAcquireGLObject( command_queue, num_objs, objs, num_events, events, event )
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -544,13 +555,13 @@ module OpenCL
     num_objs = [mem_objects].flatten.length
     objs = nil
     if num_objs > 0 then
-      objs = FFI::MemoryPointer.new(  Mem, num_objs )
+      objs = FFI::MemoryPointer::new(  Mem, num_objs )
       [mem_objects].flatten.each_with_index { |o, i|
         objs[i].write_pointer(e)
       }
     end
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueReleaseGLObject( command_queue, num_objs, objs, num_events, events, event )
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -584,7 +595,7 @@ module OpenCL
     size = (buffer.size - offset) % pattern_size
     size = options[:size] if options[:size]
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueFillBuffer( command_queue, buffer, pattern, pattern_size, offset, size, num_events, events, event )
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -612,7 +623,7 @@ module OpenCL
     OpenCL.error_check(OpenCL::INVALID_OPERATION) if command_queue.context.platform.version_number < 1.1
     origin, region = OpenCL.get_origin_region( image, options, :origin, :region )
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueFillImage( command_queue, image, fill_color, origin, region, num_events, events, event )
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -642,7 +653,7 @@ module OpenCL
     dst_offset = 0
     dst_offset = options[:dst_offset] if options[:dst_offset]
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueCopyImageToBuffer( command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events, events, event )
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -672,7 +683,7 @@ module OpenCL
     src_offset = 0
     src_offset = options[:src_offset] if options[:src_offset]
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueCopyBufferToImage( command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events, events, event )
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -711,7 +722,7 @@ module OpenCL
     input_slice_pitch = 0
     input_slice_pitch = options[:input_slice_pitch] if options[:input_slice_pitch]
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueWriteImage( command_queue, image, blocking, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events, events, event )
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -739,12 +750,12 @@ module OpenCL
   def self.enqueue_copy_image( command_queue, src_image, dst_image, options = {} )
     src_origin, src_region = OpenCL.get_origin_region( src_image, options, :src_origin, :region )
     dst_origin, dst_region = OpenCL.get_origin_region( dst_image, options, :dst_origin, :region )
-    region = FFI::MemoryPointer.new( :size_t, 3 )
+    region = FFI::MemoryPointer::new( :size_t, 3 )
     (0..2).each { |i|
       region[i].write_size_t( [src_region[i].read_size_t, dst_region[i].read_size_t].min )
     }
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueCopyImage( command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events, events, event )
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -782,14 +793,13 @@ module OpenCL
     slice_pitch = 0
     slice_pitch = options[:slice_pitch] if options[:slice_pitch]
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueReadImage( command_queue, image, blocking, origin, region, row_pitch, slice_pitch, ptr, num_events, events, event )
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
   end
 
   # Enqueues a native kernel
-  #  not yet fully implemented
   #
   # ==== Attributes
   # 
@@ -799,26 +809,46 @@ module OpenCL
   #
   # ==== Options
   #
+  # * +:args+ - if provided, a list of arguments to pass to the kernel. Arguments should have a size method and be convertible to Pointer with to_ptr
+  # * +:mem_list+ - if provided, a hash containing Buffer objects and their index inside the argument list.
   # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
   #
   # ==== Returns
   #
   # the Event associated with the command
   def self.enqueue_native_kernel( command_queue, options = {}, &func )
-#    num_mem_objects = 0
-#    mem_list = nil
-#    if options[:mem_list] then
-#      num_mem_objects = options[:mem_list].length
-#      if num_mem_objects > 0 then
-#        mem_list = FFI::MemoryPointer.new( OpenCL::Mem, num_mem_objects )
-#        options[:mem_list].each_with_index { |e, i|
-#          mem_list[i].write_pointer(e)
-#        }
-#      end
-#    end
+    arguments = options[:args]
+    arg_offset = []
+    args = nil
+    args_size = 0
+    if arguments then
+      [arguments].flatten.each { |e|
+        arg_offset.push(arg_size)
+        args_size += e.size
+      }
+      args = FFI::MemoryPointer::new(args_size)
+      [arguments].flatten.each_with_index { |e, i|
+        args.put_bytes(arg_offset[i], e.to_ptr.read_bytes(e.size))
+      }
+    end
+    num_mem_objects = 0
+    mem_list = nil
+    if options[:mem_list] then
+      num_mem_objects = options[:mem_list].length
+      if num_mem_objects > 0 then
+        mem_list = FFI::MemoryPointer::new( OpenCL::Mem, num_mem_objects )
+        mem_loc = FFI::MemoryPointer::new( Pointer, num_mem_objects )
+        i = 0
+        options[:mem_list].each { |key, value|
+          mem_list[i].write_pointer(key)
+          mem_loc[i].write_pointer(args+arg_offset[value])
+          i = i + 1
+        }
+      end
+    end
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
-    error = OpenCL.clEnqueueNativeKernel( command_queue, func, nil, 0, 0, nil, nil, num_events, events, event )
+    event = FFI::MemoryPointer::new( Event )
+    error = OpenCL.clEnqueueNativeKernel( command_queue, func, args, args_size, num_mem_objects, mem_list, mem_loc, num_events, events, event )
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
   end
@@ -840,7 +870,7 @@ module OpenCL
   # the Event associated with the command
   def self.enqueue_task( command_queue, kernel, options = {} )
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueTask( command_queue, kernel, num_events, events, event )
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -865,26 +895,26 @@ module OpenCL
   #
   # the Event associated with the command
   def self.enqueue_NDrange_kernel( command_queue, kernel, global_work_size, options={} )
-    gws = FFI::MemoryPointer.new( :size_t, global_work_size.length )
+    gws = FFI::MemoryPointer::new( :size_t, global_work_size.length )
     global_work_size.each_with_index { |g, i|
       gws[i].write_size_t(g)
     }
     lws = nil
     if options[:local_work_size] then
-      lws = FFI::MemoryPointer.new( :size_t, global_work_size.length )
+      lws = FFI::MemoryPointer::new( :size_t, global_work_size.length )
       global_work_size.each_index { |i|
         lws[i].write_size_t(options[:local_work_size][i])
       }
     end
     gwo = nil
     if options[:global_work_offset] then
-      gwo = FFI::MemoryPointer.new( :size_t, global_work_size.length )
+      gwo = FFI::MemoryPointer::new( :size_t, global_work_size.length )
       global_work_size.each_index { |i|
         gwo[i].write_size_t(options[:global_work_offset][i])
       }
     end
     num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     error = OpenCL.clEnqueueNDRangeKernel(command_queue, kernel, global_work_size.length, gwo, gws, lws, num_events, events, event)
     OpenCL.error_check(error)
     return OpenCL::Event::new(event.read_pointer, false)
@@ -918,7 +948,7 @@ module OpenCL
     if command_queue.context.platform.version_number < 1.2 then
       num_events = [events].flatten.length
       if num_events > 0 then
-        evts = FFI::MemoryPointer.new( Event, num_events )
+        evts = FFI::MemoryPointer::new( Event, num_events )
         [events].flatten.each_with_index { |e, i|
           evts[i].write_pointer(e)
         }
@@ -932,12 +962,12 @@ module OpenCL
       num_events = [events].flatten.length
       evts = nil
       if num_events > 0 then
-        evts = FFI::MemoryPointer.new( Event, num_events )
+        evts = FFI::MemoryPointer::new( Event, num_events )
         [events].flatten.each_with_index { |e, i|
           evts[i].write_pointer(e)
         }
       end
-      event = FFI::MemoryPointer.new( Event )
+      event = FFI::MemoryPointer::new( Event )
       error = OpenCL.clEnqueueBarrierWithWaitList( command_queue, num_events, evts, event )
       OpenCL.error_check(error)
       return OpenCL::Event::new(event.read_pointer, false)
@@ -955,14 +985,14 @@ module OpenCL
   #
   # an Event
   def self.enqueue_marker( command_queue, events = [] )
-    event = FFI::MemoryPointer.new( Event )
+    event = FFI::MemoryPointer::new( Event )
     if command_queue.context.platform.version_number < 1.2 then
       error = OpenCL.clEnqueueMarker( command_queue, event )
     else
       num_events = [events].flatten.length
       evts = nil
       if num_events > 0 then
-        evts = FFI::MemoryPointer.new( Event, num_events )
+        evts = FFI::MemoryPointer::new( Event, num_events )
         [events].flatten.each_with_index { |e, i|
           evts[i].write_pointer(e)
         }
@@ -978,7 +1008,7 @@ module OpenCL
 
     # Returns the Context associated to the CommandQueue
     def context
-      ptr = FFI::MemoryPointer.new( Context )
+      ptr = FFI::MemoryPointer::new( Context )
       error = OpenCL.clGetCommandQueueInfo(self, CommandQueue::CONTEXT, Context.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Context::new( ptr.read_pointer )
@@ -986,7 +1016,7 @@ module OpenCL
 
     # Returns the Device associated to the CommandQueue
     def device
-      ptr = FFI::MemoryPointer.new( Device )
+      ptr = FFI::MemoryPointer::new( Device )
       error = OpenCL.clGetCommandQueueInfo(self, CommandQueue::DEVICE, Device.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Device::new( ptr.read_pointer )
@@ -1534,11 +1564,36 @@ module OpenCL
       return OpenCL.enqueue_migrate_mem_objects( self, mem_objects, options )
     end
 
+    # Enqueues a native kernel in the CommandQueue
+    #
+    # ==== Attributes
+    # 
+    # * +options+ - a hash containing named options
+    # * +func+ - a Proc object to execute
+    #
+    # ==== Options
+    #
+    # * +:args+ - if provided, a list of arguments to pass to the kernel. Arguments should have a size method and be convertible to Pointer with to_ptr
+    # * +:mem_list+ - if provided, a hash containing Buffer objects and their index inside the argument list.
+    # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
+    #
+    # ==== Returns
+    #
+    # the Event associated with the command
+    def enqueue_native_kernel( options = {}, &func )
+      return OpenCL.enqueue_native_kernel( self, options, &func )
+    end
+
     # Blocks until all the commands in the CommandQueue have completed
     def finish
       return OpenCL.finish(self)
     end
 
+    # Issues all the commands in a CommandQueue to the Device
+    def flush
+      return OpenCL.flush( self )
+    end
+
   end
 
 end

data/lib/opencl_ruby_ffi/Context.rb

@@ -14,13 +14,13 @@ module OpenCL
   # * +:user_data+ - an FFI::Pointer or an object that can be converted into one using to_ptr. The pointer is passed to the callback.
   def self.create_context(devices, options = {}, &block)
     @@callbacks.push( block ) if block
-    pointer = FFI::MemoryPointer.new( Device, devices.size)
+    pointer = FFI::MemoryPointer::new( Device, devices.size)
     devices.size.times { |indx|
       pointer.put_pointer(indx, devices[indx])
     }
     properties = OpenCL.get_context_properties( options )
     user_data = options[:user_data]
-    error = FFI::MemoryPointer.new( :cl_int )
+    error = FFI::MemoryPointer::new( :cl_int )
     ptr = OpenCL.clCreateContext(properties, devices.size, pointer, block, user_data, error)
     OpenCL.error_check(error.read_cl_int)
     return OpenCL::Context::new(ptr, false)
@@ -42,7 +42,7 @@ module OpenCL
     @@callbacks.push( block ) if block
     properties = OpenCL.get_context_properties( options )
     user_data = options[:user_data]
-    error = FFI::MemoryPointer.new( :cl_int )
+    error = FFI::MemoryPointer::new( :cl_int )
     ptr = OpenCL.clCreateContextFromType(properties, type, block, user_data, error)
     OpenCL.error_check(error.read_cl_int)
     return OpenCL::Context::new(ptr, false)
@@ -71,12 +71,12 @@ module OpenCL
     # Returns the number of devices associated to the Context
     def num_devices
       d_n = 0
-      ptr = FFI::MemoryPointer.new( :size_t )
+      ptr = FFI::MemoryPointer::new( :size_t )
       error = OpenCL.clGetContextInfo(self, Context::DEVICES, 0, nil, ptr)
       OpenCL.error_check(error)
       d_n = ptr.read_size_t / Platform.size
 #      else
-#        ptr = FFI::MemoryPointer.new( :cl_uint )
+#        ptr = FFI::MemoryPointer::new( :cl_uint )
 #        error = OpenCL.clGetContextInfo(self, Context::NUM_DEVICES, ptr.size, ptr, nil)
 #        OpenCL.error_check(error)
 #        d_n = ptr.read_cl_uint
@@ -87,11 +87,11 @@ module OpenCL
     # Returns an Array of Device associated to the Context
     def devices
       n = self.num_devices
-      ptr2 = FFI::MemoryPointer.new( Device, n )
+      ptr2 = FFI::MemoryPointer::new( Device, n )
       error = OpenCL.clGetContextInfo(self, Context::DEVICES, Device.size*n, ptr2, nil)
       OpenCL.error_check(error)
       return ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
-        OpenCL::Device.new(device_ptr)
+        OpenCL::Device::new(device_ptr)
       }
     end
 
@@ -106,11 +106,11 @@ module OpenCL
     # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
     def supported_image_formats( image_type, options = {} )
       flags = OpenCL.get_flags( options )
-      num_image_formats = FFI::MemoryPointer.new( :cl_uint )
+      num_image_formats = FFI::MemoryPointer::new( :cl_uint )
       error = OpenCL.clGetSupportedImageFormats( self, flags, image_type, 0, nil, num_image_formats )
       OpenCL.error_check(error)
       num_entries = num_image_formats.read_cl_uint
-      image_formats = FFI::MemoryPointer.new( ImageFormat, num_entries )
+      image_formats = FFI::MemoryPointer::new( ImageFormat, num_entries )
       error = OpenCL.clGetSupportedImageFormats( self, flags, image_type, num_entries, image_formats, nil )
       OpenCL.error_check(error)
       return num_entries.times.collect { |i|
@@ -301,6 +301,43 @@ module OpenCL
       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, FFI::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
+    #
+    # * +device_list+ - an Array of Device to create the program for. Can throw an OpenCL::Invalid value if the number of supplied devices is different from the number of supplied binaries.
+    # * +binaries+ - Array of binaries 
+    def create_program_with_binary( device_list, binaries)
+       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 self.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

data/lib/opencl_ruby_ffi/Device.rb

@@ -25,7 +25,7 @@ module OpenCL
     error = OpenCL.clCreateSubDevice( in_device, props, device_number, devices_ptr, nil )
     OpenCL.error_check(error)
     devices_ptr.get_array_of_pointer(0, device_number).collect { |device_ptr|
-        OpenCL::Device.new(device_ptr, false)
+        OpenCL::Device::new(device_ptr, false)
     }
   end
 
@@ -116,19 +116,19 @@ module OpenCL
 
     # Returns the platform the Device belongs to
     def platform
-      ptr = FFI::MemoryPointer.new( OpenCL::Platform )
+      ptr = FFI::MemoryPointer::new( OpenCL::Platform )
       error = OpenCL.clGetDeviceInfo(self, Device::PLATFORM, OpenCL::Platform.size, ptr, nil)
       OpenCL.error_check(error)
-      return OpenCL::Platform.new(ptr.read_pointer)
+      return OpenCL::Platform::new(ptr.read_pointer)
     end
 
     # Returns the parent Device if it exists
     def parent_device
-      ptr = FFI::MemoryPointer.new( OpenCL::Device )
+      ptr = FFI::MemoryPointer::new( OpenCL::Device )
       error = OpenCL.clGetDeviceInfo(self, Device::PARENT_DEVICE, OpenCL::Device.size, ptr, nil)
       OpenCL.error_check(error)
       return nil if ptr.null?
-      return OpenCL::Device.new(ptr.read_pointer)
+      return OpenCL::Device::new(ptr.read_pointer)
     end
 
     # Partitions the Device in serveral sub-devices