opencl_ruby_ffi 0.993 → 0.994

data/lib/opencl_ruby_ffi/Context.rb

@@ -16,22 +16,20 @@ module OpenCL
     @@callbacks.push( block ) if block
     devs = [devices].flatten
     pointer = FFI::MemoryPointer::new( Device, devs.size)
-    devs.size.times { |indx|
-      pointer.put_pointer(indx, devs[indx])
-    }
-    properties = OpenCL.get_context_properties( options )
+    pointer.write_array_of_pointer(devs)
+    properties = get_context_properties( options )
     user_data = options[:user_data]
     error = FFI::MemoryPointer::new( :cl_int )
-    ptr = OpenCL.clCreateContext(properties, devs.size, pointer, block, user_data, error)
-    OpenCL.error_check(error.read_cl_int)
-    return OpenCL::Context::new(ptr, false)
+    ptr = clCreateContext(properties, devs.size, pointer, block, user_data, error)
+    error_check(error.read_cl_int)
+    return Context::new(ptr, false)
   end
 
   # Creates an Context using devices of the selected type
   #
   # ==== Attributes
   #
-  # * +type+ - array of Device or a single Device
+  # * +type+ - a Device::Type
   # * +options+ - a hash containing named options
   # * +block+ - if provided, a callback invoked when error arise in the context. Signature of the callback is { |FFI::Pointer to null terminated c string, FFI::Pointer to binary data, :size_t number of bytes of binary data, FFI::Pointer to user_data| ... }
   #
@@ -41,12 +39,12 @@ 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_from_type(type, options = {}, &block)
     @@callbacks.push( block ) if block
-    properties = OpenCL.get_context_properties( options )
+    properties = get_context_properties( options )
     user_data = options[:user_data]
     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)
+    ptr = clCreateContextFromType(properties, type, block, user_data, error)
+    error_check(error.read_cl_int)
+    return Context::new(ptr, false)
   end
 
   #Maps the cl_context object of OpenCL
@@ -206,7 +204,7 @@ module OpenCL
     # * +: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_2D( texture_target, texture, options = {} )
-      return OpenCL.create_from_GL_texture_2D( self, texture_target, texture, options = {} )
+      return OpenCL.create_from_GL_texture_2D( self, texture_target, texture, options )
     end
 
     # Creates an Image in the Context from an OpenGL 3D texture

data/lib/opencl_ruby_ffi/Device.rb

@@ -11,21 +11,21 @@ module OpenCL
   #
   # an Array of Device
   def self.create_sub_devices( in_device, properties )
-    OpenCL.error_check(OpenCL::INVALID_OPERATION) if in_device.platform.version_number < 1.2
+    error_check(INVALID_OPERATION) if in_device.platform.version_number < 1.2
     props = FFI::MemoryPointer::new( :cl_device_partition_property, properties.length + 1 )
     properties.each_with_index { |e,i|
       props[i].write_cl_device_partition_property(e)
     }
     props[properties.length].write_cl_device_partition_property(0)
     device_number_ptr = FFI::MemoryPointer::new( :cl_uint )
-    error = OpenCL.clCreateSubDevice( in_device, props, 0, nil, device_number_ptr )
-    OpenCL.error_check(error)
+    error = clCreateSubDevice( in_device, props, 0, nil, device_number_ptr )
+    error_check(error)
     device_number = device_number_ptr.read_cl_uint
-    devices_ptr = FFI::MemoryPointer::new( OpenCL::Device, device_number )
-    error = OpenCL.clCreateSubDevice( in_device, props, device_number, devices_ptr, nil )
-    OpenCL.error_check(error)
+    devices_ptr = FFI::MemoryPointer::new( Device, device_number )
+    error = clCreateSubDevice( in_device, props, device_number, devices_ptr, nil )
+    error_check(error)
     devices_ptr.get_array_of_pointer(0, device_number).collect { |device_ptr|
-        OpenCL::Device::new(device_ptr, false)
+        Device::new(device_ptr, false)
     }
   end
 
@@ -39,10 +39,10 @@ module OpenCL
     # Returns an Array of String corresponding to the Device extensions
     def extensions
       extensions_size = FFI::MemoryPointer::new( :size_t )
-      error = OpenCL.clGetDeviceInfo( self, OpenCL::Device::EXTENSIONS, 0, nil, extensions_size)
+      error = OpenCL.clGetDeviceInfo( self, EXTENSIONS, 0, nil, extensions_size)
       OpenCL.error_check(error)
       ext = FFI::MemoryPointer::new( extensions_size.read_size_t )
-      error = OpenCL.clGetDeviceInfo( self, OpenCL::Device::EXTENSIONS, extensions_size.read_size_t, ext, nil)
+      error = OpenCL.clGetDeviceInfo( self, EXTENSIONS, extensions_size.read_size_t, ext, nil)
       OpenCL.error_check(error)
       ext_string = ext.read_string
       return ext_string.split(" ")
@@ -51,10 +51,10 @@ module OpenCL
     # Returns an Array of String corresponding to the Device built in kernel names
     def built_in_kernels
       built_in_kernels_size = FFI::MemoryPointer::new( :size_t )
-      error = OpenCL.clGetDeviceInfo( self, OpenCL::Device::BUILT_IN_KERNELS, 0, nil, built_in_kernels_size)
+      error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS, 0, nil, built_in_kernels_size)
       OpenCL.error_check(error)
       ker = FFI::MemoryPointer::new( built_in_kernels_size.read_size_t )
-      error = OpenCL.clGetDeviceInfo( self, OpenCL::Device::BUILT_IN_KERNELS, built_in_kernels_size.read_size_t, ker, nil)
+      error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS, built_in_kernels_size.read_size_t, ker, nil)
       OpenCL.error_check(error)
       ker_string = ext.read_string
       return ker_string.split(";")
@@ -144,7 +144,7 @@ module OpenCL
       prop_names = []
       props = self.partition_properties
       %w( PARTITION_EQUALLY PARTITION_BY_COUNTS PARTITION_BY_AFFINITY_DOMAIN ).each { |prop|
-        prop_names.push(prop) if props.include?(OpenCL::Device.const_get(prop))
+        prop_names.push(prop) if props.include?(Device.const_get(prop))
       }
     end
 
@@ -156,18 +156,18 @@ module OpenCL
     # Returns the platform the Device belongs to
     def platform
       ptr = FFI::MemoryPointer::new( OpenCL::Platform )
-      error = OpenCL.clGetDeviceInfo(self, OpenCL::Device::PLATFORM, OpenCL::Platform.size, ptr, nil)
+      error = OpenCL.clGetDeviceInfo(self, PLATFORM, OpenCL::Platform.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Platform::new(ptr.read_pointer)
     end
 
     # Returns the parent Device if it exists
     def parent_device
-      ptr = FFI::MemoryPointer::new( OpenCL::Device )
-      error = OpenCL.clGetDeviceInfo(self, OpenCL::Device::PARENT_DEVICE, OpenCL::Device.size, ptr, nil)
+      ptr = FFI::MemoryPointer::new( Device )
+      error = OpenCL.clGetDeviceInfo(self, PARENT_DEVICE, Device.size, ptr, nil)
       OpenCL.error_check(error)
       return nil if ptr.null?
-      return OpenCL::Device::new(ptr.read_pointer)
+      return Device::new(ptr.read_pointer)
     end
 
     # Partitions the Device in serveral sub-devices
@@ -192,8 +192,8 @@ module OpenCL
     # ==== Returns
     #
     # an Array of Device
-    def partition_by_affinity_domain( affinity_domain = OpenCL::Device::AFFINITY_DOMAIN_NEXT_PARTITIONABLE )
-      return OpenCL.create_sub_devices( self,  [ OpenCL::Device::PARTITION_BY_AFFINITY_DOMAIN, affinity_domain ] )
+    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 containing compute_unit_number compute units
@@ -206,7 +206,7 @@ module OpenCL
     #
     # an Array of Device
     def partition_equally( compute_unit_number = 1 )
-      return OpenCL.create_sub_devices( self,  [ OpenCL::Device::PARTITION_EQUALLY, compute_unit_number ] )
+      return OpenCL.create_sub_devices( self,  [ PARTITION_EQUALLY, compute_unit_number ] )
     end
 
     # Partitions the Device in serveral sub-devices each containing a specific number of compute units
@@ -219,7 +219,7 @@ module OpenCL
     #
     # an Array of Device
     def partition_by_count( compute_unit_number_list = [1] )
-      return OpenCL.create_sub_devices( self,  [ OpenCL::Device::PARTITION_BY_COUNTS] + compute_unit_number_list + [ OpenCL::Device::PARTITION_BY_COUNTS_LIST_END ] )
+      return OpenCL.create_sub_devices( self,  [ PARTITION_BY_COUNTS] + compute_unit_number_list + [ PARTITION_BY_COUNTS_LIST_END ] )
     end
 
   end

data/lib/opencl_ruby_ffi/Event.rb

@@ -6,9 +6,9 @@ module OpenCL
   #
   # * +event_list+ - a single or an Array of Event to wait upon before returning
   def self.wait_for_events(event_list)
-    num_events, events = OpenCL.get_event_wait_list( {:event_wait_list => event_list } )
-    error = OpenCL.clWaitForEvents(num_events, events)
-    OpenCL.error_check(error)
+    num_events, events = get_event_wait_list( {:event_wait_list => event_list } )
+    error = clWaitForEvents(num_events, events)
+    error_check(error)
     return nil
   end
   
@@ -17,6 +17,7 @@ module OpenCL
   # ==== Attributes
   #
   # * +event+ - the Event to attach the callback to
+  # * +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, FFI::Pointer to user_data| ... }
   #
@@ -24,9 +25,9 @@ module OpenCL
   #
   # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
   def self.set_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)
+    error_check(INVALID_OPERATION) if event.context.platform.version_number < 1.1
+    error = clSetEventCallback( event, command_exec_callback_type, proc, options[:user_data] )
+    error_check(error)
     return self
   end
 
@@ -36,18 +37,18 @@ module OpenCL
   #
   # * +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_check(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 OpenCL::Event::new(event, false)
+    event = clCreateUserEvent(context, error)
+    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)
+    error_check(INVALID_OPERATION) if event.context.platform.version_number < 1.1
+    error = clSetUserEventStatus( event, execution_status )
+    error_check(error)
     return self
   end
 
@@ -59,9 +60,9 @@ module OpenCL
 #  # * +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 OpenCL::Event::new(event, false)
+#    event = clCreateEventFromGLsyncKHR(context, sync, error)
+#    error_check(error.read_cl_int)
+#    return Event::new(event, false)
 #  end
 
   # Maps the cl_event object
@@ -70,7 +71,7 @@ module OpenCL
     # Returns the CommandQueue associated with the Event, if it exists
     def command_queue
       ptr = FFI::MemoryPointer::new( OpenCL::CommandQueue )
-      error = OpenCL.clGetEventInfo(self, OpenCL::Event::COMMAND_QUEUE, OpenCL::CommandQueue.size, ptr, nil)
+      error = OpenCL.clGetEventInfo(self, COMMAND_QUEUE, OpenCL::CommandQueue.size, ptr, nil)
       OpenCL.error_check(error)
       pt = ptr.read_pointer
       if pt.null? then
@@ -83,7 +84,7 @@ module OpenCL
     # Returns the Context associated with the Event
     def context
       ptr = FFI::MemoryPointer::new( OpenCL::Context )
-      error = OpenCL.clGetEventInfo(self, OpenCL::Event::CONTEXT, OpenCL::Context.size, ptr, nil)
+      error = OpenCL.clGetEventInfo(self, CONTEXT, OpenCL::Context.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Context::new( ptr.read_pointer )
     end
@@ -94,7 +95,7 @@ module OpenCL
     # 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 )
+      error = OpenCL.clGetEventInfo(self, COMMAND_EXECUTION_STATUS, ptr.size, ptr, nil )
       OpenCL.error_check(error)
       return OpenCL::CommandExecutionStatus::new( ptr.read_cl_int )
     end
@@ -147,6 +148,7 @@ module OpenCL
     #
     # ==== 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, FFI::Pointer to user_data| ... }
     #
@@ -154,7 +156,7 @@ module OpenCL
     #
     # * +: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 )
+      return OpenCL.set_event_callback( self, command_exec_callback_type, options, &proc )
     end
 
     alias :set_callback :set_event_callback

data/lib/opencl_ruby_ffi/Image.rb

@@ -13,12 +13,12 @@ module OpenCL
   # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image
   # * +: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 )
+    flags = 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 OpenCL::Image::new(img_ptr, false)
+    img_ptr = clCreateImage( context, flags, format, desc, host_ptr, error )
+    error_check(error.read_cl_int)
+    return Image::new(img_ptr, false)
   end
 
   # Creates a 1D Image
@@ -35,10 +35,10 @@ module OpenCL
   # * +: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 )
+      desc = ImageDesc::new(Mem::IMAGE1D, width, 0, 0, 0, 0, 0, 0, 0, nil)
+      return create_image( context, format, desc, options )
     else
-      OpenCL.error_check(OpenCL::Error::INVALID_OPERATION)
+      error_check(INVALID_OPERATION)
     end
   end
 
@@ -59,15 +59,15 @@ module OpenCL
     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 )
+      desc = ImageDesc::new(Mem::IMAGE2D, width, height, 0, 0, row_pitch, 0, 0, 0, nil)
+      return create_image( context, format, desc, options )
     end
-    flags = OpenCL.get_flags( options )
+    flags = get_flags( options )
     host_ptr = options[:host_ptr]
     error = FFI::MemoryPointer::new( :cl_int )
-    img_ptr = OpenCL.clCreateImage2D( context, flags, format, width, height, row_pitch, host_ptr, error )
-    OpenCL.error_check(error.read_cl_int)
-    return OpenCL::Image::new(img_ptr, false)
+    img_ptr = clCreateImage2D( context, flags, format, width, height, row_pitch, host_ptr, error )
+    error_check(error.read_cl_int)
+    return Image::new(img_ptr, false)
   end
 
   # Creates a 3D Image
@@ -90,15 +90,15 @@ module OpenCL
     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 )
+      desc = ImageDesc::new(Mem::IMAGE3D, width, height, depth, 0, row_pitch, slice_pitch, 0, 0, nil)
+      return create_image( context, format, desc, flags, data )
     end
-    flags = OpenCL.get_flags( options )
+    flags = get_flags( options )
     host_ptr = options[:host_ptr]
     error = FFI::MemoryPointer::new( :cl_int )
-    img_ptr = OpenCL.clCreateImage3D( context, fs, format, width, height, depth, row_pitch, slice_pitch, d, error )
-    OpenCL.error_check(error.read_cl_int)
-    return OpenCL::Image::new(img_ptr, false)
+    img_ptr = clCreateImage3D( context, fs, format, width, height, depth, row_pitch, slice_pitch, d, error )
+    error_check(error.read_cl_int)
+    return Image::new(img_ptr, false)
   end
 
   # Creates an Image from an OpenGL render buffer
@@ -111,13 +111,13 @@ module OpenCL
   #
   # ==== 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)
+  # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image (default Mem::READ_WRITE)
   def self.create_from_GL_render_buffer( context, renderbuffer, options = {} )
-    flags = OpenCL.get_flags( options )
+    flags = get_flags( options )
     error = FFI::MemoryPointer::new( :cl_int )
-    img = OpenCL.clCreateFromGLRenderBuffer( context, flags, renderbuffer, error )
-    OpenCL.error_check(error.read_cl_int)
-    return OpenCL::Image::new( img, false )
+    img = clCreateFromGLRenderBuffer( context, flags, renderbuffer, error )
+    error_check(error.read_cl_int)
+    return Image::new( img, false )
   end
 
   # Creates an Image from an OpenGL texture
@@ -132,18 +132,18 @@ module OpenCL
   # ==== 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)
+  # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image (default 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)
+      error_check(INVALID_OPERATION)
     end
-    flags = OpenCL.get_flags( options )
+    flags = 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 OpenCL::Image::new( img, false )
+    img = clCreateFromGLTexture( context, flags, texture_target, miplevel, texture, error )
+    error_check(error.read_cl_int)
+    return Image::new( img, false )
   end
 
   # Creates an Image from an OpenGL 2D texture
@@ -160,15 +160,15 @@ 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_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 )
+      return create_from_GL_texture( context, texture_target, texture, options )
     end
-    flags = OpenCL.get_flags( options )
+    flags = 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 OpenCL::Image::new( img, false )
+    img = clCreateFromGLTexture2D( context, flags, texture_target, miplevel, texture, error )
+    error_check(error.read_cl_int)
+    return Image::new( img, false )
   end
 
   # Creates an Image from an OpenGL 3D texture
@@ -185,15 +185,15 @@ 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_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 )
+      return create_from_GL_texture( context, texture_target, texture, options )
     end
-    flags = OpenCL.get_flags( options )
+    flags = 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 OpenCL::Image::new( img, false )
+    img = clCreateFromGLTexture3D( context, flags, texture_target, miplevel, texture, error )
+    error_check(error.read_cl_int)
+    return Image::new( img, false )
   end
 
   # Maps the cl_mem OpenCL objects of type CL_MEM_OBJECT_IMAGE*
@@ -250,7 +250,7 @@ module OpenCL
     # Returns the ImageFormat corresponding to the image
     def format
       image_format = FFI::MemoryPointer::new( OpenCL::ImageFormat )
-      error = OpenCL.clGetImageInfo( self, OpenCL::Image::FORMAT, image_format.size, image_format, nil)
+      error = OpenCL.clGetImageInfo( self, FORMAT, image_format.size, image_format, nil)
       OpenCL.error_check(error)
       return OpenCL::ImageFormat::from_pointer( image_format )
     end
@@ -258,7 +258,7 @@ module OpenCL
     # 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)
+      error = OpenCL.clGetImageInfo(self,  BUFFER, OpenCL::Buffer.size, ptr, nil)
       OpenCL.error_check(error)
       return nil if ptr.null?
       return OpenCL::Buffer::new(ptr.read_pointer)

data/lib/opencl_ruby_ffi/Kernel.rb

@@ -3,23 +3,23 @@ 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)
+    error = clCreateKernelsInProgram( program, 0, nil, num_ptr )
+    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)
+    kernels_ptr = FFI::MemoryPointer::new( Kernel, num_kernels )
+    error =  clCreateKernelsInProgram( program, num_kernels, kernels_ptr, 0 )
+    error_check(error)
     return kernels_ptr.get_array_of_pointer(0, num_kernels).collect { |kernel_ptr|
-      OpenCL::Kernel::new(kernel_ptr, false)
+      Kernel::new(kernel_ptr, false)
     }
   end
 
   # Returns the Kernel corresponding the the specified name in the given Program
   def self.create_kernel(program, name)
     error = FFI::MemoryPointer::new( :cl_int )
-    kernel_ptr = OpenCL.clCreateKernel(program, name, error)
-    OpenCL.error_check(error.read_cl_int)
-    return OpenCL::Kernel::new( kernel_ptr, false )
+    kernel_ptr = clCreateKernel(program, name, error)
+    error_check(error.read_cl_int)
+    return Kernel::new( kernel_ptr, false )
   end
 
   # Set the index th argument of Kernel to value. size of value can be specified
@@ -27,12 +27,12 @@ module OpenCL
     sz = size
     sz = value.class.size if sz == nil
     val = value
-    if value.kind_of?(OpenCL::Mem) then
-      val = FFI::MemoryPointer::new( OpenCL::Mem )
+    if value.kind_of?(Mem) then
+      val = FFI::MemoryPointer::new( Mem )
       val.write_pointer(value.to_ptr)
     end
-    error = OpenCL.clSetKernelArg( kernel, index, sz, val )
-    OpenCL.error_check(error)
+    error = clSetKernelArg( kernel, index, sz, val )
+    error_check(error)
   end
 
   # Maps the cl_kernel object
@@ -55,37 +55,37 @@ module OpenCL
       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)
+        error = OpenCL.clGetKernelArgInfo(@kernel, @index, ADDRESS_QUALIFIER, ptr.size, ptr, nil)
         OpenCL.error_check(error)
-        return OpenCL::Kernel::Arg::AddressQualifier::new( ptr.read_cl_kernel_arg_address_qualifier )
+        return 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)
+        error = OpenCL.clGetKernelArgInfo(@kernel, @index, ACCESS_QUALIFIER, ptr.size, ptr, nil)
         OpenCL.error_check(error)
-        return OpenCL::Kernel::Arg::AccessQualifier::new( ptr.read_cl_kernel_arg_access_qualifier )
+        return 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)
+        error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_QUALIFIER, ptr.size, ptr, nil)
         OpenCL.error_check(error)
-        return OpenCL::Kernel::Arg::TypeQualifier::new( ptr.read_cl_kernel_arg_type_qualifier )
+        return 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)
+        error = OpenCL.clGetKernelArgInfo(@kernel, @index, 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)
+        error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_NAME, ptr1.read_size_t, ptr2, nil)
         OpenCL.error_check(error)
         return ptr2.read_string
       end
@@ -94,10 +94,10 @@ module OpenCL
       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)
+        error = OpenCL.clGetKernelArgInfo(@kernel, @index, 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)
+        error = OpenCL.clGetKernelArgInfo(@kernel, @index, NAME, ptr1.read_size_t, ptr2, nil)
         OpenCL.error_check(error)
         return ptr2.read_string
       end
@@ -118,7 +118,7 @@ module OpenCL
       n = self.num_args
       a = []
       n.times { |i|
-        a.push OpenCL::Kernel::Arg::new(self, i)
+        a.push Arg::new(self, i)
       }
       return a
     end
@@ -131,7 +131,7 @@ module OpenCL
       pointers.each_with_index { |p, i|
         pt[i].write_pointer(p)
       }
-      error = OpenCL.clSetKernelExecInfo( self, OpenCL::Kernel::EXEC_INFO_SVM_PTRS, pt.size, pt)
+      error = OpenCL.clSetKernelExecInfo( self, EXEC_INFO_SVM_PTRS, pt.size, pt)
       OpenCL.error_check(error)
       return self
     end
@@ -141,7 +141,7 @@ module OpenCL
       OpenCL.error_check(OpenCL::INVALID_OPERATION) if self.context.platform.version_number < 2.0
       pt = FFI::MemoryPointer::new(  :cl_bool )
       pt.write_cl_bool( flag )
-      error = OpenCL.clSetKernelExecInfo( self, OpenCL::Kernel::EXEC_INFO_SVM_FINE_GRAIN_SYSTEL, pt.size, pt)
+      error = OpenCL.clSetKernelExecInfo( self, EXEC_INFO_SVM_FINE_GRAIN_SYSTEL, pt.size, pt)
       OpenCL.error_check(error)
       return self
     end
@@ -173,7 +173,7 @@ module OpenCL
     # Returns the Context the Kernel is associated with
     def context
       ptr = FFI::MemoryPointer::new( Context )
-      error = OpenCL.clGetKernelInfo(self, OpenCL::Kernel::CONTEXT, Context.size, ptr, nil)
+      error = OpenCL.clGetKernelInfo(self, CONTEXT, Context.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Context::new( ptr.read_pointer )
     end
@@ -181,7 +181,7 @@ module OpenCL
     # Returns the Program the Kernel was created from
     def program
       ptr = FFI::MemoryPointer::new( Program )
-      error = OpenCL.clGetKernelInfo(self, OpenCL::Kernel::PROGRAM, Program.size, ptr, nil)
+      error = OpenCL.clGetKernelInfo(self, PROGRAM, Program.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Program::new(ptr.read_pointer)
     end

data/lib/opencl_ruby_ffi/Mem.rb

@@ -6,15 +6,15 @@ module OpenCL
   #
   # * +memobj+ - the Mem to attach the callback to
   # * +options+ - a hash containing named options
-  # * +block+ - if provided, a callback invoked when memobj is released. Signature of the callback is { |Mem, FFI::Pointer to user_data| ... }
+  # * +block+ - if provided, a callback invoked when memobj is released. Signature of the callback is { |FFI::Poniter to the deleted Mem, 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_mem_object_destructor_callback( memobj, options = {}, &proc )
+  def self.set_mem_object_destructor_callback( memobj, options = {}, &block )
     @@callbacks.push( block ) if block
-    error = OpenCL.clSetMemObjectDestructorCallback( memobj, block, options[:user_data] )
-    OpenCL.error_check(error)
+    error = clSetMemObjectDestructorCallback( memobj, block, options[:user_data] )
+    error_check(error)
     return self
   end
 
@@ -24,7 +24,7 @@ module OpenCL
     # Returns the Context associated to the Mem
     def context
       ptr = FFI::MemoryPointer::new( Context )
-      error = OpenCL.clGetMemObjectInfo(self, OpenCL::Mem::CONTEXT, Context.size, ptr, nil)
+      error = OpenCL.clGetMemObjectInfo(self, CONTEXT, Context.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Context::new( ptr.read_pointer )
     end
@@ -37,10 +37,10 @@ module OpenCL
     # Returns the Buffer this Buffer was created from using create_sub_buffer
     def associated_memobject
       ptr = FFI::MemoryPointer::new( Mem )
-      error = OpenCL.clGetMemObjectInfo(self, OpenCL::Mem::ASSOCIATED_MEMOBJECT, Mem.size, ptr, nil)
+      error = OpenCL.clGetMemObjectInfo(self, ASSOCIATED_MEMOBJECT, Mem.size, ptr, nil)
       OpenCL.error_check(error)
       return nil if ptr.read_pointer.null?
-      return OpenCL::Mem::new( ptr.read_pointer )
+      return Mem::new( ptr.read_pointer )
     end
 
     ##
@@ -96,7 +96,8 @@ module OpenCL
     #
     # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
     def set_destructor_callback( options = {}, &proc )
-      return OpenCL.set_mem_object_destructor_callback( self, options, &proc )
+      OpenCL.set_mem_object_destructor_callback( self, options, &proc )
+      return self
     end
 
     # Returns the texture_target argument specified in create_from_GL_texture for Mem