opencl_ruby_ffi 1.1.0 → 1.2.0

data/lib/opencl_ruby_ffi/Mem.rb

@@ -1,3 +1,4 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
 module OpenCL
 
   # Attaches a callback to memobj the will be called on memobj destruction
@@ -6,7 +7,7 @@ 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 { |FFI::Poniter to the deleted Mem, FFI::Pointer to user_data| ... }
+  # * +block+ - if provided, a callback invoked when memobj is released. Signature of the callback is { |Poniter to the deleted Mem, Pointer to user_data| ... }
   #
   # ==== Options
   #
@@ -33,7 +34,7 @@ module OpenCL
 
     # Returns the Context associated to the Mem
     def context
-      ptr = FFI::MemoryPointer::new( Context )
+      ptr = MemoryPointer::new( Context )
       error = OpenCL.clGetMemObjectInfo(self, CONTEXT, Context.size, ptr, nil)
       error_check(error)
       return Context::new( ptr.read_pointer )
@@ -46,7 +47,7 @@ module OpenCL
 
     # Returns the Buffer this Buffer was created from using create_sub_buffer
     def associated_memobject
-      ptr = FFI::MemoryPointer::new( Mem )
+      ptr = MemoryPointer::new( Mem )
       error = OpenCL.clGetMemObjectInfo(self, ASSOCIATED_MEMOBJECT, Mem.size, ptr, nil)
       error_check(error)
       return nil if ptr.read_pointer.null?
@@ -100,7 +101,7 @@ module OpenCL
     # ==== Attributes
     #
     # * +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 { |Mem, Pointer to user_data| ... }
     #
     # ==== Options
     #
@@ -112,7 +113,7 @@ module OpenCL
 
     # Returns the texture_target argument specified in create_from_GL_texture for Mem
     def gl_texture_target
-      param_value = FFI::MemoryPointer::new( :cl_GLenum )
+      param_value = MemoryPointer::new( :cl_GLenum )
       error = OpenCL.clGetGLTextureInfo( self, GL_TEXTURE_TARGET, param_value.size, param_value, nil )
       error_check(error)
       return param_value.read_cl_GLenum
@@ -121,7 +122,7 @@ module OpenCL
 
     # Returns the miplevel argument specified in create_from_GL_texture for Mem
     def gl_mimap_level
-      param_value = FFI::MemoryPointer::new( :cl_GLint )
+      param_value = MemoryPointer::new( :cl_GLint )
       error = OpenCL.clGetGLTextureInfo( self, GL_MIPMAP_LEVEL, param_value.size, param_value, nil )
       error_check(error)
       return param_value.read_cl_GLint
@@ -130,7 +131,7 @@ module OpenCL
 
     # Returns the type of the GL object associated with Mem
     def gl_object_type
-      param_value = FFI::MemoryPointer::new( :cl_gl_object_type )
+      param_value = MemoryPointer::new( :cl_gl_object_type )
       error = OpenCL.clGetGLObjectInfo( self, param_value, nil )
       error_check(error)
       return GLObjectType::new(param_value.read_cl_gl_object_type)
@@ -139,7 +140,7 @@ module OpenCL
 
     # Returns the name of the GL object associated with Mem
     def gl_object_name
-      param_value = FFI::MemoryPointer::new( :cl_GLuint )
+      param_value = MemoryPointer::new( :cl_GLuint )
       error = OpenCL.clGetGLObjectInfo( self, nil, param_value )
       error_check(error)
       return param_value.read_cl_GLuint

data/lib/opencl_ruby_ffi/Pipe.rb

@@ -1,3 +1,4 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
 module OpenCL
 
   # Creates a Pipe
@@ -14,7 +15,7 @@ module OpenCL
   def self.create_pipe( context, pipe_packet_size, pipe_max_packets, options = {} )
     error_check(INVALID_OPERATION) if self.context.platform.version_number < 2.0
     flags = get_flags( options )
-    error = FFI::MemoryPointer::new( :cl_int )
+    error = MemoryPointer::new( :cl_int )
     pipe_ptr = clCreatePipe( context, flags, pipe_packet_size, pipe_max_packets, nil, error)
     error_check(error.read_cl_int)
     return Pipe::new(pipe_ptr, false)

data/lib/opencl_ruby_ffi/Platform.rb

@@ -1,3 +1,4 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
 module OpenCL
 
   # Unloads a Platform compiler
@@ -19,22 +20,22 @@ module OpenCL
     return nil
   end
 
-  # Returns an FFI::Function corresponding to an extension function
+  # Returns a Function corresponding to an extension function
   #
   # ==== Attributes
   #
   # * +name+ - a String representing the name of the function
   # * +return_type+ - the type of data returned by the function
   # * +param_types+ - an Array of types, corresponding to the parameters type
-  # * +options+ - if given, a hash of named options that will be given to FFI::Function::new. See FFI doc for details.
+  # * +options+ - if given, a hash of named options that will be given to Function::new. See FFI doc for details.
   def self.get_extension_function( name, return_type, param_types, options = {} )
-    name_p = FFI::MemoryPointer.from_string(name)
+    name_p = MemoryPointer.from_string(name)
     ptr = clGetExtensionFunctionAddress( name_p )
     return nil if ptr.null?
-    return FFI::Function::new(return_type, param_types, ptr, options)
+    return Function::new(return_type, param_types, ptr, options)
   end
 
-  # Returns an FFI::Function corresponding to an extension function for the Platform
+  # Returns a Function corresponding to an extension function for the Platform
   #
   # ==== Attributes
   #
@@ -42,22 +43,22 @@ module OpenCL
   # * +name+ - a String representing the name of the function
   # * +return_type+ - the type of data returned by the function
   # * +param_types+ - an Array of types, corresponding to the parameters type
-  # * +options+ - if given, a hash of named options that will be given to FFI::Function::new. See FFI doc for details.
+  # * +options+ - if given, a hash of named options that will be given to Function::new. See FFI doc for details.
   def self.get_extension_function_for_platform( platform, name, return_type, param_types, options = {} )
     error_check(INVALID_OPERATION) if platform.version_number < 1.2
-    name_p = FFI::MemoryPointer.from_string(name)
+    name_p = MemoryPointer.from_string(name)
     ptr = clGetExtensionFunctionAddressForPlatform( platform, name_p )
     return nil if ptr.null?
-    return FFI::Function::new(return_type, param_types, ptr, options)
+    return Function::new(return_type, param_types, ptr, options)
   end
 
   # Returns an Array of Platform containing the available OpenCL platforms
   def self.get_platforms
-    ptr1 = FFI::MemoryPointer::new(:cl_uint , 1)
+    ptr1 = MemoryPointer::new(:cl_uint , 1)
     
     error = clGetPlatformIDs(0, nil, ptr1)
     error_check(error)
-    ptr2 = FFI::MemoryPointer::new(:pointer, ptr1.read_uint)
+    ptr2 = MemoryPointer::new(:pointer, ptr1.read_uint)
     error = clGetPlatformIDs(ptr1.read_uint(), ptr2, nil)
     error_check(error)
     return ptr2.get_array_of_pointer(0,ptr1.read_uint()).collect { |platform_ptr|
@@ -111,10 +112,10 @@ module OpenCL
 
     # Returns an Array of string corresponding to the Platform extensions
     def extensions
-      extensions_size = FFI::MemoryPointer::new( :size_t )
+      extensions_size = MemoryPointer::new( :size_t )
       error = OpenCL.clGetPlatformInfo( 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.clGetPlatformInfo( self, EXTENSIONS, extensions_size.read_size_t, ext, nil)
       error_check(error)
       ext_string = ext.read_string
@@ -124,10 +125,10 @@ module OpenCL
     # Returns an Array of Device corresponding to the available devices on the Platform
     # The type of the desired devices can be specified
     def devices(type = Device::Type::ALL)
-      ptr1 = FFI::MemoryPointer::new(:cl_uint , 1)
+      ptr1 = MemoryPointer::new(:cl_uint , 1)
       error = OpenCL.clGetDeviceIDs(self, type, 0, nil, ptr1)
       error_check(error)
-      ptr2 = FFI::MemoryPointer::new(:pointer, ptr1.read_uint)
+      ptr2 = MemoryPointer::new(:pointer, ptr1.read_uint)
       error = OpenCL.clGetDeviceIDs(self, type, ptr1.read_uint(), ptr2, nil)
       error_check(error)
       return ptr2.get_array_of_pointer(0, ptr1.read_uint()).collect { |device_ptr|
@@ -147,16 +148,16 @@ module OpenCL
       return OpenCL.unload_platform_compiler(self)
     end
 
-    # Returns an FFI::Function corresponding to an extension function for a Platform
+    # Returns a Function corresponding to an extension function for a Platform
     #
     # ==== Attributes
     #
     # * +name+ - a String representing the name of the function
     # * +return_type+ - the type of data returned by the function
     # * +param_types+ - an Array of types, corresponding to the parameters type
-    # * +options+ - if given, a hash of named options that will be given to FFI::Function::new. See FFI doc for details.
+    # * +options+ - if given, a hash of named options that will be given to Function::new. See FFI doc for details.
     def get_extension_function( name, return_type, param_types, options = {} )
-      return OpenCL.get_extension_function( self, name, return_type, param_types, options )
+      return OpenCL.get_extension_function_for_platform( self, name, return_type, param_types, options )
     end
 
     # Creates a Context gathering devices of a certain type and belonging to this Platform
@@ -165,12 +166,12 @@ module OpenCL
     #
     # * +type+ - type of device to be used
     # * +options+ - if given, a hash of 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| ... }
+    # * +block+ - if provided, a callback invoked when error arise in the context. Signature of the callback is { |Pointer to null terminated c string, Pointer to binary data, :size_t number of bytes of binary data, Pointer to user_data| ... }
     #
     # ==== Options
     # 
     # * +:properties+ - a list of :cl_context_properties, the Platform will be prepended
-    # * +:user_data+ - an FFI::Pointer or an object that can be converted into one using to_ptr. The pointer is passed to the callback.
+    # * +:user_data+ - an Pointer or an object that can be converted into one using to_ptr. The pointer is passed to the callback.
     def create_context_from_type(type, options = {}, &block)
       props = [ Context::PLATFORM, self ]
       if options[:properties] then

data/lib/opencl_ruby_ffi/Program.rb

@@ -1,3 +1,4 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
 module OpenCL
 
   # Builds (compile and link) a Program created from sources or binary
@@ -6,7 +7,7 @@ module OpenCL
   #
   # * +program+ - the program to build
   # * +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| ... }
+  # * +block+ - if provided, a callback invoked when the Program is built. Signature of the callback is { |Program, Pointer to user_data| ... }
   #
   # ==== Options
   #
@@ -18,7 +19,7 @@ module OpenCL
     num_devices, devices_p = get_device_list( options )
     opt = ""
     opt = options[:options] if options[:options]
-    options_p = FFI::MemoryPointer.from_string(opt)
+    options_p = MemoryPointer.from_string(opt)
     error = clBuildProgram(program, num_devices, devices_p, options_p, block, options[:user_data] )
     error_check(error)
     return program
@@ -31,7 +32,7 @@ module OpenCL
   # * +context+ - Context the created Program will be associated with
   # * +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| ... }
+  # * +block+ - if provided, a callback invoked when the Program is built. Signature of the callback is { |Program, Pointer to user_data| ... }
   #
   # ==== Options
   #
@@ -43,12 +44,12 @@ module OpenCL
     num_devices, devices_p = get_device_list( options )
     opt = ""
     opt = options[:options] if options[:options]
-    options_p = FFI::MemoryPointer.from_string(opt)
+    options_p = MemoryPointer.from_string(opt)
     programs = [input_programs].flatten
     num_programs = programs.length
-    programs_p = FFI::MemoryPointer::new( Program, num_programs )
+    programs_p = MemoryPointer::new( Program, num_programs )
     programs_p.write_array_of_pointer(programs)
-    error = FFI::MemoryPointer::new( :cl_int )
+    error = MemoryPointer::new( :cl_int )
     prog = clLinkProgram( context, num_devices, devices_p, options_p, num_programs, programs_p, block, options[:user_data], error)
     error_check(error.read_cl_int)
     return Program::new( prog, false )
@@ -60,7 +61,7 @@ module OpenCL
   #
   # * +program+ - the program to build
   # * +options+ - a Hash containing named options
-  # * +block+ - if provided, a callback invoked when the Program is compiled. Signature of the callback is { |Program, FFI::Pointer to user_data| ... }
+  # * +block+ - if provided, a callback invoked when the Program is compiled. Signature of the callback is { |Program, Pointer to user_data| ... }
   #
   # ==== Options
   #
@@ -73,19 +74,19 @@ module OpenCL
     num_devices, devices_p = get_device_list( options )
     opt = ""
     opt = options[:options] if options[:options]
-    options_p = FFI::MemoryPointer.from_string(opt)
+    options_p = MemoryPointer.from_string(opt)
     headers = options[:input_headers]
     headers_p = nil
     header_include_names = nil
     num_headers = 0
     num_headers = headers.length if headers
     if num_headers then
-      headers_p = FFI::MemoryPointer::new( Program, num_headers )
-      header_include_names = FFI::MemoryPointer::new( :pointer, num_headers )
+      headers_p = MemoryPointer::new( Program, num_headers )
+      header_include_names = MemoryPointer::new( :pointer, num_headers )
       indx = 0
       headers.each { |key, value|
         headers_p[indx].write_pointer(value)
-        header_include_names[indx] = FFI::MemoryPointer.from_string(key)
+        header_include_names[indx] = MemoryPointer.from_string(key)
         indx = indx + 1
       }
     end
@@ -104,13 +105,13 @@ module OpenCL
   def self.create_program_with_built_in_kernels(context, device_list, kernel_names)
     devices = [device_list].flatten
     num_devices = devices.length
-    devices_p = FFI::MemoryPointer::new( Device, num_devices )
+    devices_p = MemoryPointer::new( Device, num_devices )
     num_devices.times { |indx|
       devices_p[indx].write_pointer(devices[indx])
     }
     names = [kernel_names].flatten.join(",")
-    names_p = FFI::MemoryPointer.from_string(names)
-    error = FFI::MemoryPointer::new( :cl_int )
+    names_p = MemoryPointer.from_string(names)
+    error = MemoryPointer::new( :cl_int )
     prog = clCreateProgramWithBuiltInKernels( context, num_devices, devices_p, names_p, error )
     error_check(error.read_cl_int)
     return Program::new(prog, false)
@@ -128,18 +129,18 @@ module OpenCL
     num_devices = bins.length
     devices = [device_list].flatten
     error_check(INVALID_VALUE) if devices.length != bins.length
-    devices_p = FFI::MemoryPointer::new( Device, num_devices )
-    lengths = FFI::MemoryPointer::new( :size_t, num_devices )
-    binaries_p = FFI::MemoryPointer::new( :pointer, num_devices )
+    devices_p = MemoryPointer::new( Device, num_devices )
+    lengths = MemoryPointer::new( :size_t, num_devices )
+    binaries_p = MemoryPointer::new( :pointer, num_devices )
     num_devices.times { |indx|
       devices_p[indx].write_pointer(devices[indx])
       lengths[indx].write_size_t(binaries[indx].bytesize)
-      p = FFI::MemoryPointer::new(binaries[indx].bytesize)
+      p = MemoryPointer::new(binaries[indx].bytesize)
       p.write_bytes(binaries[indx])
       binaries_p[indx].write_pointer(p)
     }
-    binary_status = FFI::MemoryPointer::new( :cl_int, num_devices )
-    error = FFI::MemoryPointer::new( :cl_int )
+    binary_status = MemoryPointer::new( :cl_int, num_devices )
+    error = MemoryPointer::new( :cl_int )
     prog = clCreateProgramWithBinary(context, num_devices, devices_p, lengths, binaries_p, binary_status, error)
     error_check(error.read_cl_int)
     d_s = []
@@ -163,24 +164,24 @@ module OpenCL
       strs = [strings].flatten
     end
     n_strs = strs.size
-    strs_lengths = FFI::MemoryPointer::new( :size_t, n_strs )
-    c_strs = FFI::MemoryPointer::new( :pointer, n_strs )
+    strs_lengths = MemoryPointer::new( :size_t, n_strs )
+    c_strs = MemoryPointer::new( :pointer, n_strs )
 
     c_strs_p = []
     strs.each { |str|
       if str then
-        c_strs_p.push (FFI::MemoryPointer.from_string(str))
+        c_strs_p.push (MemoryPointer.from_string(str))
       end
     }
     error_check(INVALID_VALUE) if c_strs_p.size == 0
 
-    c_strs = FFI::MemoryPointer::new( :pointer, c_strs_p.size )
-    c_strs_length = FFI::MemoryPointer::new( :size_t, c_strs_p.size )
+    c_strs = MemoryPointer::new( :pointer, c_strs_p.size )
+    c_strs_length = MemoryPointer::new( :size_t, c_strs_p.size )
     c_strs_p.each_with_index { |p, i|
       c_strs[i].write_pointer(p)
       c_strs_length[i].write_size_t(p.size)
     }
-    error = FFI::MemoryPointer::new( :cl_int )
+    error = MemoryPointer::new( :cl_int )
     program_ptr = clCreateProgramWithSource(context, c_strs_p.size, c_strs, c_strs_length, error)
     error_check(error.read_cl_int)
     return Program::new( program_ptr, false )
@@ -195,8 +196,8 @@ module OpenCL
   def self.create_program_with_il(context, il)
     error_check(INVALID_OPERATION) if context.platform.version_number < 2.1
     length = il.bytesize
-    il_p = FFI::MemoryPointer::new( length )
-    error = FFI::MemoryPointer::new( :cl_int )
+    il_p = MemoryPointer::new( length )
+    error = MemoryPointer::new( :cl_int )
     il_p.write_bytes(il)
     program_ptr = clCreateProgramWithIL(context, il_p, length, error)
     error_check(error.read_cl_int)
@@ -249,10 +250,10 @@ module OpenCL
       if context.platform.version_number < 1.2 then
         return kernels.collect(&:name)
       else
-        kernel_names_size = FFI::MemoryPointer::new( :size_t )
+        kernel_names_size = MemoryPointer::new( :size_t )
         error = OpenCL.clGetProgramInfo( self, KERNEL_NAMES, 0, nil, kernel_names_size)
         error_check(error)
-        k_names = FFI::MemoryPointer::new( kernel_names_size.read_size_t )
+        k_names = MemoryPointer::new( kernel_names_size.read_size_t )
         error = OpenCL.clGetProgramInfo( self, KERNEL_NAMES, kernel_names_size.read_size_t, k_names, nil)
         error_check(error)
         k_names_string = k_names.read_string
@@ -267,7 +268,7 @@ module OpenCL
     def build_global_variable_total_size(devs = nil)
       devs = self.devices if not devs
       devs = [devs].flatten
-      ptr = FFI::MemoryPointer::new( :size_t )
+      ptr = MemoryPointer::new( :size_t )
       return devs.collect { |dev|
         error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_GLOBAL_VARIABLE_TOTAL_SIZE, ptr.size, ptr, nil)
         error_check(error)
@@ -279,7 +280,7 @@ module OpenCL
     def build_status(devs = nil)
       devs = self.devices if not devs
       devs = [devs].flatten
-      ptr = FFI::MemoryPointer::new( :cl_build_status )
+      ptr = MemoryPointer::new( :cl_build_status )
       return devs.collect { |dev|
         error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_STATUS, ptr.size, ptr, nil)
         error_check(error)
@@ -291,7 +292,7 @@ module OpenCL
     def binary_type(devs = nil)
       devs = self.devices if not devs
       devs = [devs].flatten
-      ptr = FFI::MemoryPointer::new( :cl_program_binary_type )
+      ptr = MemoryPointer::new( :cl_program_binary_type )
       return devs.collect { |dev|
         error = OpenCL.clGetProgramBuildInfo(self, dev, BINARY_TYPE, ptr.size, ptr, nil)
         error_check(error)
@@ -304,10 +305,10 @@ module OpenCL
       devs = self.devices if not devs
       devs = [devs].flatten
       return devs.collect { |dev|
-        ptr1 = FFI::MemoryPointer::new( :size_t, 1)
+        ptr1 = MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_OPTIONS, 0, nil, ptr1)
         error_check(error)
-        ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
+        ptr2 = MemoryPointer::new( ptr1.read_size_t )
         error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_OPTIONS, ptr1.read_size_t, ptr2, nil)
         error_check(error)
         [dev, ptr2.read_string]
@@ -319,10 +320,10 @@ module OpenCL
       devs = self.devices if not devs
       devs = [devs].flatten
       return devs.collect { |dev|
-        ptr1 = FFI::MemoryPointer::new( :size_t, 1)
+        ptr1 = MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_LOG, 0, nil, ptr1)
         error_check(error)
-        ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
+        ptr2 = MemoryPointer::new( ptr1.read_size_t )
         error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_LOG, ptr1.read_size_t, ptr2, nil)
         error_check(error)
         [dev, ptr2.read_string]
@@ -332,12 +333,12 @@ module OpenCL
     # Returns the binaries associated to the Program for each Device. Returns an Array of tuple [ Device, String ]
     def binaries
       sizes = self.binary_sizes
-      bin_array = FFI::MemoryPointer::new( :pointer, sizes.length )
+      bin_array = MemoryPointer::new( :pointer, sizes.length )
       sizes.length
       total_size = 0
       sizes.each_with_index { |s, i|
         total_size += s
-        bin_array[i].write_pointer(FFI::MemoryPointer::new(s))
+        bin_array[i].write_pointer(MemoryPointer::new(s))
       }
       error = OpenCL.clGetProgramInfo(self, BINARIES, total_size, bin_array, nil)
       error_check(error)
@@ -351,12 +352,12 @@ module OpenCL
 
     # Return the intermediate level representation of the program if any, nil otherwise
     def il
-      il_size = FFI::MemoryPointer::new( :size_t )
+      il_size = MemoryPointer::new( :size_t )
       error = OpenCL.clGetProgramInfo(self, IL, 0, nil, il_size)
       error_check(error)
       return nil if il_size == 0
       length = il_size.read_size_t
-      il_p = FFI::MemoryPointer::new( length )
+      il_p = MemoryPointer::new( length )
       error = OpenCL.clGetProgramInfo(self, IL, length, il_p, nil)
       error_check(error)
       return il_p.read_bytes(length)
@@ -367,7 +368,7 @@ module OpenCL
     # ==== Attributes
     #
     # * +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| ... }
+    # * +block+ - if provided, a callback invoked when the Program is built. Signature of the callback is { |Program, Pointer to user_data| ... }
     #
     # ==== Options
     # * +:device_list+ - an Array of Device to build the program for
@@ -382,7 +383,7 @@ module OpenCL
     # ==== Attributes
     #
     # * +options+ - a Hash containing named options
-    # * +block+ - if provided, a callback invoked when the Program is compiled. Signature of the callback is { |Program, FFI::Pointer to user_data| ... }
+    # * +block+ - if provided, a callback invoked when the Program is compiled. Signature of the callback is { |Program, Pointer to user_data| ... }
     #
     # ==== Options
     #
@@ -396,7 +397,7 @@ module OpenCL
 
     # Returns the Context the Program is associated to
     def context
-      ptr = FFI::MemoryPointer::new( Context )
+      ptr = MemoryPointer::new( Context )
       error = OpenCL.clGetProgramInfo(self, CONTEXT, Context.size, ptr, nil)
       error_check(error)
       return Context::new( ptr.read_pointer )
@@ -416,7 +417,7 @@ module OpenCL
     # Returns the Array of Device the Program is associated with
     def devices
       n = self.num_devices
-      ptr2 = FFI::MemoryPointer::new( Device, n )
+      ptr2 = MemoryPointer::new( Device, n )
       error = OpenCL.clGetProgramInfo(self, DEVICES, Device.size*n, ptr2, nil)
       error_check(error)
       return ptr2.get_array_of_pointer(0, n).collect { |device_ptr|

data/lib/opencl_ruby_ffi/SVM.rb

@@ -1,7 +1,8 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
 module OpenCL
 
   # maps the SVM pointer type
-  class SVMPointer < FFI::Pointer
+  class SVMPointer < Pointer
 
     # create a new SVMPointer from its address and the context it pertains to
     def initialize( address, context, size, base = nil )
@@ -79,7 +80,7 @@ module OpenCL
   # * +command_queue+ - CommandQueue used to execute the write command
   # * +svm_pointer+ - a single or an Array of SVMPointer (or Pointer)
   # * +options+ - a hash containing named options
-  # * +block+ - if provided, a callback invoked to free the pointers. Signature of the callback is { |CommandQueue, num_pointers, FFI::Pointer to an array of num_pointers Pointers, FFI::Pointer to user_data| ... }
+  # * +block+ - if provided, a callback invoked to free the pointers. Signature of the callback is { |CommandQueue, num_pointers, Pointer to an array of num_pointers Pointers, Pointer to user_data| ... }
   #
   # ==== Options
   #
@@ -93,12 +94,12 @@ module OpenCL
     error_check(INVALID_OPERATION) if command_queue.context.platform.version_number < 2.0
     pointers = [svm_pointers].flatten
     num_pointers = pointers.length
-    ptr = FFI::MemoryPointer::new( :pointer, num_pointers)
+    ptr = MemoryPointer::new( :pointer, num_pointers)
     pointers.each_with_index { |p, indx|
       ptr[indx].write_pointer(p)
     }
     num_events, events = get_event_wait_list( options )
-    event = FFI::MemoryPointer::new( Event )
+    event = MemoryPointer::new( Event )
     error = clEnqueueSVMFree(command_queue, num_pointers, ptr, block, options[:user_data], num_events, events, event)
     error_check(error)
     return Event::new(event.read_pointer, false)
@@ -128,7 +129,7 @@ module OpenCL
     blocking = FALSE
     blocking = TRUE if options[:blocking] or options[:blocking_copy]
     num_events, events = get_event_wait_list( options )
-    event = FFI::MemoryPointer::new( Event )
+    event = MemoryPointer::new( Event )
     error = clEnqueueSVMMemcpy(command_queue, blocking, dst_ptr, src_ptr, size, num_events, events, event)
     error_check(error)
     return Event::new(event.read_pointer, false)
@@ -156,7 +157,7 @@ module OpenCL
     num_events, events = get_event_wait_list( options )
     pattern_size = pattern.size
     pattern_size = options[:pattern_size] if options[:pattern_size]
-    event = FFI::MemoryPointer::new( Event )
+    event = MemoryPointer::new( Event )
     error = clEnqueueSVMMemFill(command_queue, svm_ptr, pattern, pattern_size, size, num_events, events, event)
     error_check(error)
     return Event::new(event.read_pointer, false)
@@ -187,7 +188,7 @@ module OpenCL
     blocking = TRUE if options[:blocking] or options[:blocking_map]
     flags = get_flags( {:flags => map_flags} )
     num_events, events = get_event_wait_list( options )
-    event = FFI::MemoryPointer::new( Event )
+    event = MemoryPointer::new( Event )
     error = clEnqueueSVMMap( command_queue, blocking, flags, svm_ptr, size, num_events, events, event )
     error_check( error.read_cl_int )
     return Event::new( event.read_ptr, false )
@@ -211,7 +212,7 @@ module OpenCL
   def self.enqueue_svm_unmap( command_queue, svm_ptr, options = {} )
     error_check(INVALID_OPERATION) if command_queue.context.platform.version_number < 2.0
     num_events, events = get_event_wait_list( options )
-    event = FFI::MemoryPointer::new( Event )
+    event = MemoryPointer::new( Event )
     error = clEnqueueSVMUnmap( command_queue, svm_ptr, num_events, events, event )
     error_check( error )
     return Event::new( event.read_ptr, false )
@@ -241,15 +242,15 @@ module OpenCL
     flags = get_flags( options )
     sizes = [0]*num_svm_pointers
     sizes = options[:sizes] if options[:sizes]
-    svn_ptrs_p = FFI::MemoryPointer::new( :pointer, num_svm_pointers)
+    svn_ptrs_p = MemoryPointer::new( :pointer, num_svm_pointers)
     svn_ptrs.each_with_index { |e, i|
       svn_ptrs_p[i].write_pointer(e)
     }
-    sizes_p = FFI::MemoryPointer::new( :size_t, num_svm_pointers)
+    sizes_p = MemoryPointer::new( :size_t, num_svm_pointers)
     num_svm_pointers.times { |i|
       sizes_p[i].write_size_t(sizes[i])
     }
-    event = FFI::MemoryPointer::new( Event )
+    event = MemoryPointer::new( Event )
     error =  clEnqueueSVMMigrateMem( command_queue, num_svm_pointers, svn_ptrs_p, sizes_p, flags, num_events, events, event )
     error_check( error )
     return Event::new( event.read_ptr, false )

data/lib/opencl_ruby_ffi/Sampler.rb

@@ -1,3 +1,4 @@
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
 module OpenCL
 
   # Creates a Sampler
@@ -21,7 +22,7 @@ module OpenCL
     addressing_mode = options[:addressing_mode] if options[:addressing_mode]
     filter_mode = FilterMode::NEAREST
     filter_mode = options[:filter_mode] if options[:filter_mode]
-    error = FFI::MemoryPointer::new( :cl_int )
+    error = MemoryPointer::new( :cl_int )
     if context.platform.version_number < 2.0 then
       sampler_ptr = clCreateSampler( context, normalized_coords, addressing_mode, filter_mode, error )
     else
@@ -29,7 +30,7 @@ module OpenCL
       prop_size += 2 if options[:mip_filter_mode]
       prop_size += 2 if options[:lod_min]
       prop_size += 2 if options[:lod_max]
-      properties = FFI::MemoryPointer::new( :cl_sampler_info )
+      properties = MemoryPointer::new( :cl_sampler_info )
       properties[0].write_cl_sampler_info( Sampler::NORMALIZED_COORDS )
       properties[1].write_cl_bool( normalized_coords )
       properties[2].write_cl_sampler_info( Sampler::ADDRESSING_MODE )
@@ -73,7 +74,7 @@ module OpenCL
 
     # Returns the context associated with the Sampler
     def context
-      ptr = FFI::MemoryPointer::new( Context )
+      ptr = MemoryPointer::new( Context )
       error = OpenCL.clGetSamplerInfo(self, CONTEXT, Context.size, ptr, nil)
       error_check(error)
       return Context::new( ptr.read_pointer )