opencl_ruby_ffi 1.1.0 → 1.2.0

data/lib/opencl_ruby_ffi/Device.rb

@@ -1,3 +1,4 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
 module OpenCL
 
   # Splits a Device in serveral sub-devices
@@ -12,16 +13,16 @@ module OpenCL
   # an Array of Device
   def self.create_sub_devices( in_device, properties )
     error_check(INVALID_OPERATION) if in_device.platform.version_number < 1.2
-    props = FFI::MemoryPointer::new( :cl_device_partition_property, properties.length + 1 )
+    props = 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 )
+    device_number_ptr = MemoryPointer::new( :cl_uint )
     error = clCreateSubDevices( in_device, props, 0, nil, device_number_ptr )
     error_check(error)
     device_number = device_number_ptr.read_cl_uint
-    devices_ptr = FFI::MemoryPointer::new( Device, device_number )
+    devices_ptr = MemoryPointer::new( Device, device_number )
     error = clCreateSubDevices( in_device, props, device_number, devices_ptr, nil )
     error_check(error)
     devices_ptr.get_array_of_pointer(0, device_number).collect { |device_ptr|
@@ -31,8 +32,8 @@ module OpenCL
 
   def self.get_device_and_host_timer( device )
     error_check(INVALID_OPERATION) if device.platform.version_number < 2.1
-    device_timestamp_p = FFI::MemoryPointer::new( :cl_ulong )
-    host_timestamp_p = FFI::MemoryPointer::new( :cl_ulong )
+    device_timestamp_p = MemoryPointer::new( :cl_ulong )
+    host_timestamp_p = MemoryPointer::new( :cl_ulong )
     error = clGetDeviceAndHostTimer( device, device_timestamp_p, host_timestamp_p)
     error_check(error)
     return [ device_timestamp_p.read_cl_ulong, host_timestamp_p.read_cl_ulong ]
@@ -40,7 +41,7 @@ module OpenCL
 
   def self.get_device_and_host_timer( device )
     error_check(INVALID_OPERATION) if device.platform.version_number < 2.1
-    host_timestamp_p = FFI::MemoryPointer::new( :cl_ulong )
+    host_timestamp_p = MemoryPointer::new( :cl_ulong )
     error = clGetHostTimer( device, host_timestamp_p)
     error_check(error)
     return host_timestamp_p.read_cl_ulong
@@ -64,10 +65,10 @@ module OpenCL
 
     # Returns an Array of String corresponding to the Device extensions
     def extensions
-      extensions_size = FFI::MemoryPointer::new( :size_t )
+      extensions_size = MemoryPointer::new( :size_t )
       error = OpenCL.clGetDeviceInfo( self, EXTENSIONS, 0, nil, extensions_size)
       error_check(error)
-      ext = FFI::MemoryPointer::new( extensions_size.read_size_t )
+      ext = MemoryPointer::new( extensions_size.read_size_t )
       error = OpenCL.clGetDeviceInfo( self, EXTENSIONS, extensions_size.read_size_t, ext, nil)
       error_check(error)
       ext_string = ext.read_string
@@ -76,10 +77,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 )
+      built_in_kernels_size = MemoryPointer::new( :size_t )
       error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS, 0, nil, built_in_kernels_size)
       error_check(error)
-      ker = FFI::MemoryPointer::new( built_in_kernels_size.read_size_t )
+      ker = MemoryPointer::new( built_in_kernels_size.read_size_t )
       error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS, built_in_kernels_size.read_size_t, ker, nil)
       error_check(error)
       ker_string = ker.read_string
@@ -88,10 +89,10 @@ module OpenCL
 
     # Return an Array of String corresponding to the SPIR versions supported by the device
     def spir_versions
-      spir_versions_size = FFI::MemoryPointer::new( :size_t )
+      spir_versions_size = MemoryPointer::new( :size_t )
       error = OpenCL.clGetDeviceInfo( self, SPIR_VERSIONS, 0, nil, spir_versions_size)
       error_check(error)
-      vers = FFI::MemoryPointer::new( spir_versions_size.read_size_t )
+      vers = MemoryPointer::new( spir_versions_size.read_size_t )
       error = OpenCL.clGetDeviceInfo( self, SPIR_VERSIONS, spir_versions_size.read_size_t, vers, nil)
       error_check(error)
       vers_string = vers.read_string
@@ -194,13 +195,13 @@ module OpenCL
     # :method: partition_properties()
     # Returns the list of partition types supported by the Device
     def partition_properties
-      ptr1 = FFI::MemoryPointer::new( :size_t, 1)
+      ptr1 = MemoryPointer::new( :size_t, 1)
       error = OpenCL.clGetDeviceInfo(self, PARTITION_PROPERTIES, 0, nil, ptr1)
       error_check(error)
-      ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
+      ptr2 = MemoryPointer::new( ptr1.read_size_t )
       error = OpenCL.clGetDeviceInfo(self, PARTITION_PROPERTIES, ptr1.read_size_t, ptr2, nil)
       error_check(error)
-      arr = ptr2.get_array_of_cl_device_partition_property(0, ptr1.read_size_t/ FFI.find_type(:cl_device_partition_property).size)
+      arr = ptr2.get_array_of_cl_device_partition_property(0, ptr1.read_size_t/ OpenCL.find_type(:cl_device_partition_property).size)
       arr.reject! { |e| e.null? }
       return arr.collect { |e| Partition::new(e.to_i) }
     end
@@ -219,19 +220,19 @@ module OpenCL
     # :method: partition_type()
     # Returns a list of :cl_device_partition_property used to create the Device
     def partition_type
-      ptr1 = FFI::MemoryPointer::new( :size_t, 1)
+      ptr1 = MemoryPointer::new( :size_t, 1)
       error = OpenCL.clGetDeviceInfo(self, PARTITION_TYPE, 0, nil, ptr1)
       error_check(error)
-      ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
+      ptr2 = MemoryPointer::new( ptr1.read_size_t )
       error = OpenCL.clGetDeviceInfo(self, PARTITION_TYPE, ptr1.read_size_t, ptr2, nil)
       error_check(error)
-      arr = ptr2.get_array_of_cl_device_partition_property(0, ptr1.read_size_t/ FFI.find_type(:cl_device_partition_property).size)
+      arr = ptr2.get_array_of_cl_device_partition_property(0, ptr1.read_size_t/ OpenCL.find_type(:cl_device_partition_property).size)
       if arr.first.to_i == Partition::BY_NAMES_EXT then
         arr_2 = []
         arr_2.push(Partition::new(arr.first.to_i))
         i = 1
         return arr_2 if arr.length <= i
-        while arr[i].to_i - (0x1 << FFI::Pointer.size * 8) != Partition::BY_NAMES_LIST_END_EXT do
+        while arr[i].to_i - (0x1 << Pointer.size * 8) != Partition::BY_NAMES_LIST_END_EXT do
           arr_2[i] = arr[i].to_i
           i += 1
           return arr_2 if arr.length <= i
@@ -247,7 +248,7 @@ module OpenCL
 
     # Returns the Platform the Device belongs to
     def platform
-      ptr = FFI::MemoryPointer::new( OpenCL::Platform )
+      ptr = MemoryPointer::new( OpenCL::Platform )
       error = OpenCL.clGetDeviceInfo(self, PLATFORM, OpenCL::Platform.size, ptr, nil)
       error_check(error)
       return OpenCL::Platform::new(ptr.read_pointer)
@@ -255,7 +256,7 @@ module OpenCL
 
     # Returns the parent Device if it exists
     def parent_device
-      ptr = FFI::MemoryPointer::new( Device )
+      ptr = MemoryPointer::new( Device )
       error = OpenCL.clGetDeviceInfo(self, PARENT_DEVICE, Device.size, ptr, nil)
       error_check(error)
       return nil if ptr.null?

data/lib/opencl_ruby_ffi/Event.rb

@@ -1,3 +1,4 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
 module OpenCL
 
   # Waits for the command identified by Event objects to complete
@@ -19,7 +20,7 @@ module OpenCL
   # * +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| ... }
+  # * +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
   #
@@ -38,7 +39,7 @@ module OpenCL
   # * +context+ - Context the created Event will be associated to
   def self.create_user_event(context)
     error_check(INVALID_OPERATION) if context.platform.version_number < 1.1
-    error = FFI::MemoryPointer::new(:cl_int)
+    error = MemoryPointer::new(:cl_int)
     event = clCreateUserEvent(context, error)
     error_check(error.read_cl_int)
     return Event::new(event, false)
@@ -59,7 +60,7 @@ module OpenCL
 #  # * +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)
+#    error = MemoryPointer::new(:cl_int)
 #    event = clCreateEventFromGLsyncKHR(context, sync, error)
 #    error_check(error.read_cl_int)
 #    return Event::new(event, false)
@@ -79,7 +80,7 @@ module OpenCL
 
     # Returns the CommandQueue associated with the Event, if it exists
     def command_queue
-      ptr = FFI::MemoryPointer::new( CommandQueue )
+      ptr = MemoryPointer::new( CommandQueue )
       error = OpenCL.clGetEventInfo(self, COMMAND_QUEUE, CommandQueue.size, ptr, nil)
       error_check(error)
       pt = ptr.read_pointer
@@ -92,7 +93,7 @@ module OpenCL
 
     # Returns the Context associated with the Event
     def context
-      ptr = FFI::MemoryPointer::new( Context )
+      ptr = MemoryPointer::new( Context )
       error = OpenCL.clGetEventInfo(self, CONTEXT, Context.size, ptr, nil)
       error_check(error)
       return Context::new( ptr.read_pointer )
@@ -103,7 +104,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 )
+      ptr = MemoryPointer::new( :cl_int )
       error = OpenCL.clGetEventInfo(self, COMMAND_EXECUTION_STATUS, ptr.size, ptr, nil )
       error_check(error)
       return CommandExecutionStatus::new( ptr.read_cl_int )
@@ -116,7 +117,7 @@ module OpenCL
 
     # Returns the date the command corresponding to Event was queued
     def profiling_command_queued
-       ptr = FFI::MemoryPointer::new( :cl_ulong )
+       ptr = MemoryPointer::new( :cl_ulong )
        error = OpenCL.clGetEventProfilingInfo(self, PROFILING_COMMAND_QUEUED, ptr.size, ptr, nil )
        error_check(error)
        return ptr.read_cl_ulong
@@ -124,7 +125,7 @@ module OpenCL
 
     # Returns the date the command corresponding to Event was submited
     def profiling_command_submit
-       ptr = FFI::MemoryPointer::new( :cl_ulong )
+       ptr = MemoryPointer::new( :cl_ulong )
        error = OpenCL.clGetEventProfilingInfo(self, PROFILING_COMMAND_SUBMIT, ptr.size, ptr, nil )
        error_check(error)
        return ptr.read_cl_ulong
@@ -132,7 +133,7 @@ module OpenCL
 
     # Returns the date the command corresponding to Event started
     def profiling_command_start
-       ptr = FFI::MemoryPointer::new( :cl_ulong )
+       ptr = MemoryPointer::new( :cl_ulong )
        error = OpenCL.clGetEventProfilingInfo(self, PROFILING_COMMAND_START, ptr.size, ptr, nil )
        error_check(error)
        return ptr.read_cl_ulong
@@ -140,7 +141,7 @@ module OpenCL
 
     # Returns the date the command corresponding to Event ended
     def profiling_command_end
-       ptr = FFI::MemoryPointer::new( :cl_ulong )
+       ptr = MemoryPointer::new( :cl_ulong )
        error = OpenCL.clGetEventProfilingInfo(self, PROFILING_COMMAND_END, ptr.size, ptr, nil )
        error_check(error)
        return ptr.read_cl_ulong
@@ -159,7 +160,7 @@ module OpenCL
     #
     # * +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| ... }
+    # * +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
     #

data/lib/opencl_ruby_ffi/GLExt.rb

@@ -1,25 +1,26 @@
 require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
 
 module OpenCL
 
-  name_p = FFI::MemoryPointer.from_string("clGetGLContextInfoKHR")
+  name_p = MemoryPointer.from_string("clGetGLContextInfoKHR")
   p = clGetExtensionFunctionAddress(name_p)
   if p then
-    func = FFI::Function::new(:cl_int, [:pointer, :cl_gl_context_info, :size_t, :pointer, :pointer], p)
+    func = Function::new( :cl_int, [:pointer, :cl_gl_context_info, :size_t, :pointer, :pointer], p)
     func.attach(OpenCL, "clGetGLContextInfoKHR")
 
     def self.get_gl_context_info_khr( properties, param_name )
-      props = FFI::MemoryPointer::new( :cl_context_properties, properties.length + 1 )
+      props = MemoryPointer::new( :cl_context_properties, properties.length + 1 )
       properties.each_with_index { |e,i|
         props[i].write_cl_context_properties(e)
       }
       props[properties.length].write_cl_context_properties(0)
-      size_p = FFI::MemoryPointer::new( :size_t )
+      size_p = MemoryPointer::new( :size_t )
       error = clGetGLContextInfoKHR( props, param_name, 0, nil, size_p )
       error_check(error)
       size = size_p.read_size_t
       nb_devices = size/Device.size
-      values = FFI::MemoryPointer::new( Device, nb_devices )
+      values = MemoryPointer::new( Device, nb_devices )
       error = clGetGLContextInfoKHR( props, param_name, size, values, nil )
       error_check(error)
       return values.get_array_of_pointer(0, nb_devices).collect { |device_ptr|
@@ -28,15 +29,15 @@ module OpenCL
     end
   end
 
-  name_p = FFI::MemoryPointer.from_string("clCreateEventFromGLsyncKHR")
+  name_p = MemoryPointer.from_string("clCreateEventFromGLsyncKHR")
   p = clGetExtensionFunctionAddress(name_p)
   if p then
-    func = FFI::Function::new(OpenCL::find_type(Event), [OpenCL::find_type(Context), :pointer, :pointer], p)
+    func = Function::new( Event, [Context, :pointer, :pointer], p)
     func.attach(OpenCL, "clCreateEventFromGLsyncKHR")
 
     def self.create_event_from_glsync_khr( context, sync)
       error_check(INVALID_OPERATION) if context.platform.version_number < 1.1
-      error_p = FFI::MemoryPointer::new( :cl_int )
+      error_p = MemoryPointer::new( :cl_int )
       event = clCreateEventFromGLsyncKHR( context, sync, error_p )
       error_check(error_p.read_cl_int)
       return Event::new( event, false )

data/lib/opencl_ruby_ffi/Image.rb

@@ -1,3 +1,4 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
 module OpenCL
 
   # Creates an Image
@@ -15,7 +16,7 @@ module OpenCL
   def self.create_image( context, format, desc, options = {} )
     flags = get_flags( options )
     host_ptr = options[:host_ptr]
-    error = FFI::MemoryPointer::new( :cl_int )
+    error = MemoryPointer::new( :cl_int )
     img_ptr = clCreateImage( context, flags, format, desc, host_ptr, error )
     error_check(error.read_cl_int)
     return Image::new(img_ptr, false)
@@ -67,7 +68,7 @@ module OpenCL
     end
     flags = get_flags( options )
     host_ptr = options[:host_ptr]
-    error = FFI::MemoryPointer::new( :cl_int )
+    error = MemoryPointer::new( :cl_int )
     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)
@@ -101,7 +102,7 @@ module OpenCL
     end
     flags = get_flags( options )
     host_ptr = options[:host_ptr]
-    error = FFI::MemoryPointer::new( :cl_int )
+    error = MemoryPointer::new( :cl_int )
     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)
@@ -123,7 +124,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_render_buffer( context, renderbuffer, options = {} )
     flags = get_flags( options )
-    error = FFI::MemoryPointer::new( :cl_int )
+    error = MemoryPointer::new( :cl_int )
     img = clCreateFromGLRenderBuffer( context, flags, renderbuffer, error )
     error_check(error.read_cl_int)
     return Image::new( img, false )
@@ -152,7 +153,7 @@ module OpenCL
     flags = get_flags( options )
     miplevel = 0
     miplevel =  options[:miplevel] if options[:miplevel]
-    error = FFI::MemoryPointer::new( :cl_int )
+    error = MemoryPointer::new( :cl_int )
     img = clCreateFromGLTexture( context, flags, texture_target, miplevel, texture, error )
     error_check(error.read_cl_int)
     return Image::new( img, false )
@@ -180,7 +181,7 @@ module OpenCL
     flags = get_flags( options )
     miplevel = 0
     miplevel =  options[:miplevel] if options[:miplevel]
-    error = FFI::MemoryPointer::new( :cl_int )
+    error = MemoryPointer::new( :cl_int )
     img = clCreateFromGLTexture2D( context, flags, texture_target, miplevel, texture, error )
     error_check(error.read_cl_int)
     return Image::new( img, false )
@@ -208,7 +209,7 @@ module OpenCL
     flags = get_flags( options )
     miplevel = 0
     miplevel =  options[:miplevel] if options[:miplevel]
-    error = FFI::MemoryPointer::new( :cl_int )
+    error = MemoryPointer::new( :cl_int )
     img = clCreateFromGLTexture3D( context, flags, texture_target, miplevel, texture, error )
     error_check(error.read_cl_int)
     return Image::new( img, false )
@@ -276,15 +277,15 @@ module OpenCL
 
     # Returns the ImageFormat corresponding to the image
     def format
-      image_format = FFI::MemoryPointer::new( ImageFormat )
+      image_format = MemoryPointer::new( ImageFormat )
       error = OpenCL.clGetImageInfo( self, FORMAT, image_format.size, image_format, nil)
       error_check(error)
-      return ImageFormat::from_pointer( image_format )
+      return ImageFormat::new( image_format )
     end
 
     # Returns the associated Buffer if any, nil otherwise
     def buffer
-      ptr = FFI::MemoryPointer::new( Buffer )
+      ptr = MemoryPointer::new( Buffer )
       error = OpenCL.clGetImageInfo(self,  BUFFER, Buffer.size, ptr, nil)
       error_check(error)
       return nil if ptr.null?

data/lib/opencl_ruby_ffi/Kernel.rb

@@ -1,12 +1,13 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
 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 )
+    num_ptr = MemoryPointer::new( :cl_uint )
     error = clCreateKernelsInProgram( program, 0, nil, num_ptr )
     error_check(error)
     num_kernels = num_ptr.read_cl_uint
-    kernels_ptr = FFI::MemoryPointer::new( Kernel, num_kernels )
+    kernels_ptr = MemoryPointer::new( Kernel, num_kernels )
     error =  clCreateKernelsInProgram( program, num_kernels, kernels_ptr, nil )
     error_check(error)
     return kernels_ptr.get_array_of_pointer(0, num_kernels).collect { |kernel_ptr|
@@ -16,7 +17,7 @@ module OpenCL
 
   # Returns the Kernel corresponding the the specified name in the given Program
   def self.create_kernel(program, name)
-    error = FFI::MemoryPointer::new( :cl_int )
+    error = MemoryPointer::new( :cl_int )
     kernel_ptr = clCreateKernel(program, name, error)
     error_check(error.read_cl_int)
     return Kernel::new( kernel_ptr, false )
@@ -28,7 +29,7 @@ module OpenCL
     sz = value.class.size if sz == nil
     val = value
     if value.kind_of?(Mem) then
-      val = FFI::MemoryPointer::new( Mem )
+      val = MemoryPointer::new( Mem )
       val.write_pointer(value.to_ptr)
     end
     error = clSetKernelArg( kernel, index, sz, val )
@@ -37,7 +38,7 @@ module OpenCL
 
   def self.clone_kernel( kernel )
     error_check(INVALID_OPERATION) if kernel.context.platform.version_number < 2.1
-    error = FFI::MemoryPointer::new( :cl_int )
+    error = MemoryPointer::new( :cl_int )
     kernel_ptr = clCloneKernel( kernel, error )
     error_check(error.read_cl_int)
     return Kernel::new( kernel_ptr, false )
@@ -76,7 +77,7 @@ module OpenCL
       # Returns an AddressQualifier corresponding to the Arg
       def address_qualifier
         error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
-        ptr = FFI::MemoryPointer::new( :cl_kernel_arg_address_qualifier )
+        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 )
@@ -85,7 +86,7 @@ module OpenCL
       # Returns an AccessQualifier corresponding to the Arg
       def access_qualifier
         error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
-        ptr = FFI::MemoryPointer::new( :cl_kernel_arg_access_qualifier )
+        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 )
@@ -94,7 +95,7 @@ module OpenCL
       # Returns a TypeQualifier corresponding to the Arg
       def type_qualifier
         error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
-        ptr = FFI::MemoryPointer::new( :cl_kernel_arg_type_qualifier )
+        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 )
@@ -103,10 +104,10 @@ module OpenCL
       # 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 = FFI::MemoryPointer::new( :size_t, 1)
+        ptr1 = MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_NAME, 0, nil, ptr1)
         error_check(error)
-        ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
+        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
@@ -115,10 +116,10 @@ module OpenCL
       # Returns a String corresponding to the Arg name
       def name
         error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
-        ptr1 = FFI::MemoryPointer::new( :size_t, 1)
+        ptr1 = MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, NAME, 0, nil, ptr1)
         error_check(error)
-        ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
+        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
@@ -149,7 +150,7 @@ module OpenCL
     def set_svm_ptrs( ptrs )
       error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.0
       pointers = [ptrs].flatten
-      pt = FFI::MemoryPointer::new( :pointer, pointers.length )
+      pt = MemoryPointer::new( :pointer, pointers.length )
       pointers.each_with_index { |p, i|
         pt[i].write_pointer(p)
       }
@@ -161,7 +162,7 @@ module OpenCL
     # 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 = FFI::MemoryPointer::new(  :cl_bool )
+      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)
@@ -194,7 +195,7 @@ module OpenCL
 
     # Returns the Context the Kernel is associated with
     def context
-      ptr = FFI::MemoryPointer::new( Context )
+      ptr = MemoryPointer::new( Context )
       error = OpenCL.clGetKernelInfo(self, CONTEXT, Context.size, ptr, nil)
       error_check(error)
       return Context::new( ptr.read_pointer )
@@ -202,49 +203,49 @@ module OpenCL
 
     # Returns the Program the Kernel was created from
     def program
-      ptr = FFI::MemoryPointer::new( Program )
+      ptr = MemoryPointer::new( Program )
       error = OpenCL.clGetKernelInfo(self, PROGRAM, Program.size, ptr, nil)
       error_check(error)
       return Program::new(ptr.read_pointer)
     end
 
     def work_group_size(device = program.devices.first)
-      ptr = FFI::MemoryPointer::new( :size_t )
+      ptr = MemoryPointer::new( :size_t )
       error = OpenCL.clGetKernelWorkGroupInfo(self, device, WORK_GROUP_SIZE, ptr.size, ptr, nil)
       error_check(error)
       return ptr.read_size_t
     end
 
     def compile_work_group_size(device = program.devices.first)
-      ptr = FFI::MemoryPointer::new( :size_t, 3 )
+      ptr = MemoryPointer::new( :size_t, 3 )
       error = OpenCL.clGetKernelWorkGroupInfo(self, device, COMPILE_WORK_GROUP_SIZE, ptr.size, ptr, nil)
       error_check(error)
       return ptr.get_array_of_size_t(0,3)
     end
 
     def local_mem_size(device = program.devices.first)
-      ptr = FFI::MemoryPointer::new( :cl_ulong )
+      ptr = MemoryPointer::new( :cl_ulong )
       error = OpenCL.clGetKernelWorkGroupInfo(self, device, LOCAL_MEM_SIZE, ptr.size, ptr, nil)
       error_check(error)
       return ptr.read_cl_ulong
     end
 
     def preferred_work_group_size_multiple(device = program.devices.first)
-      ptr = FFI::MemoryPointer::new( :size_t )
+      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 = FFI::MemoryPointer::new( :cl_ulong )
+      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 = FFI::MemoryPointer::new( :size_t, 3 )
+      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)
@@ -252,7 +253,7 @@ module OpenCL
 
     def max_num_sub_groups(device = program.devices.first)
       error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.1
-      ptr = FFI::MemoryPointer::new( :size_t )
+      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
@@ -260,7 +261,7 @@ module OpenCL
 
     def compile_num_sub_groups(device = program.devices.first)
       error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.1
-      ptr = FFI::MemoryPointer::new( :size_t )
+      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
@@ -269,11 +270,11 @@ module OpenCL
     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 = FFI::MemoryPointer::new( :size_t, local_work_size.length )
+      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 = FFI::MemoryPointer::new( :size_t )
+      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
@@ -282,11 +283,11 @@ module OpenCL
     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 = FFI::MemoryPointer::new( :size_t, local_work_size.length )
+      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 = FFI::MemoryPointer::new( :size_t )
+      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
@@ -294,12 +295,12 @@ module OpenCL
 
     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 = FFI::MemoryPointer::new( :size_t )
+      sgp_p = MemoryPointer::new( :size_t )
       sgp_p.write_size_t(sub_group_number)
-      size_ptr = FFI::MemoryPointer::new( :size_t )
+      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 = FFI::MemoryPointer::new( size_ptr.read_size_t )
+      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)