opencl_ruby_ffi 1.1.0 → 1.2.0

data/lib/opencl_ruby_ffi/opencl_ruby_ffi_base.rb

@@ -1,53 +1,38 @@
-module FFI
-
-  class Pointer
-    alias_method :orig_method_missing, :method_missing
-    # if a missing write_type, read_type, get_array_of_type can transitively get a replacement, an alias is created and the method is called
-    def method_missing(m, *a, &b)
-      if m.to_s.match("read_")
-        type = m.to_s.sub("read_","")
-        type = FFI.find_type(type.to_sym)
-        type, _ = FFI::TypeDefs.find do |(name, t)|
-          Pointer.method_defined?("read_#{name}") if t == type
-        end
-        eval "alias :#{m} :read_#{type}" if type
-        return eval "read_#{type}( *a, &b)" if type
-      elsif m.to_s.match ("write_")
-        type = m.to_s.sub("write_","")
-        type = FFI.find_type(type.to_sym)
-        type, _ = FFI::TypeDefs.find do |(name, t)|
-          Pointer.method_defined?("write_#{name}") if t == type
-        end
-        eval "alias :#{m} :write_#{type}" if type
-        return eval "write_#{type}( *a, &b)" if type
-      elsif m.to_s.match ("get_array_of_")
-        type = m.to_s.sub("get_array_of_","")
-        type = FFI.find_type(type.to_sym)
-        type, _ = FFI::TypeDefs.find do |(name, t)|
-          Pointer.method_defined?("get_array_of_#{name}") if t == type
-        end
-        eval "alias :#{m} :get_array_of_#{type}" if type
-        return eval "get_array_of_#{type}( *a, &b)" if type
-      end
-      orig_method_missing m, *a, &b
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
 
-    end  
-  end
+module OpenCL
 
-  class Struct
+  class Pointer < FFI::Pointer
+    def initialize(*args)
+      if args.length == 2 then
+        super(OpenCL::find_type(args[0]), args[1])
+      else
+        super(*args)
+      end
+    end
+  end
 
-    # alias initialize in order to call it from another function from a child class
-    alias_method :parent_initialize, :initialize
+  class Function < FFI::Function
+    def initialize(ret, args, *opts, &block)
+      super(OpenCL::find_type(ret), args.collect { |a| OpenCL::find_type(a) }, *opts, &block)
+    end
   end
 
-end
+  class MemoryPointer < FFI::MemoryPointer
 
-module OpenCL
+    def initialize(size, count = 1, clear = true)
+      if size.is_a?(Symbol)
+        size = OpenCL::find_type(size)
+      end
+      super(size, count, clear)
+    end
+
+  end
 
   @@callbacks = []
 
   # Maps the :cl_image_fomat type of OpenCL
-  class ImageFormat < FFI::Struct
+  class ImageFormat < Struct
     layout :image_channel_order, :cl_channel_order,
            :image_channel_data_type, :cl_channel_type
 
@@ -56,10 +41,14 @@ module OpenCL
     end
 
     # Creates a new ImageFormat from an image channel order and data type
-    def initialize( image_channel_order, image_channel_data_type )
-      super()
-      self[:image_channel_order] = image_channel_order
-      self[:image_channel_data_type] = image_channel_data_type
+    def initialize( image_channel_order, image_channel_data_type = nil )
+      if image_channel_order.is_a?(FFI::Pointer) and image_channel_data_type.nil? then
+        super(image_channel_order)
+      else
+        super()
+        self[:image_channel_order] = image_channel_order
+        self[:image_channel_data_type] = image_channel_data_type
+      end
     end
 
     # Returns a new ChannelOrder corresponding to the ImageFormat internal value
@@ -87,21 +76,10 @@ module OpenCL
       return "{ #{self.channel_order}, #{self.channel_data_type} }"
     end
 
-    # A workaroud to call the parent initialize from another function (from_pointer)
-    def parent_initialize(ptr)
-      super(ptr)
-    end
-
-    # Creates a new ImageFormat using an FFI::Pointer, fonctionality was lost when initialize was defined
-    def self.from_pointer( ptr )
-      object = allocate
-      object.parent_initialize( ptr )
-      object
-    end
   end
 
   # Map the :cl_image_desc type of OpenCL
-  class ImageDesc < FFI::Struct
+  class ImageDesc < Struct
     layout :image_type,           :cl_mem_object_type,
            :image_width,          :size_t,
            :image_height,         :size_t,
@@ -130,7 +108,7 @@ module OpenCL
   end
 
   # Maps the :cl_buffer_region type of OpenCL
-  class BufferRegion < FFI::Struct
+  class BufferRegion < Struct
     layout :origin, :size_t,
            :size,   :size_t
 
@@ -168,7 +146,7 @@ module OpenCL
       num_events = 0
       if events and events.size > 0 then
         num_events = events.size
-        events_p = FFI::MemoryPointer::new( Event, num_events )
+        events_p = MemoryPointer::new( Event, num_events )
         events_p.write_array_of_pointer(events)
       end
       return [num_events, events_p]
@@ -189,14 +167,14 @@ module OpenCL
   
     # Extracts the origin_symbol and region_symbol named options for image from the given hash. Returns the read (or detemined suitable) origin and region in a tuple
     def get_origin_region( image, options, origin_symbol, region_symbol )
-      origin = FFI::MemoryPointer::new( :size_t, 3 )
+      origin = MemoryPointer::new( :size_t, 3 )
       (0..2).each { |i| origin[i].write_size_t(0) }
       if options[origin_symbol] then
         options[origin_symbol].each_with_index { |e, i|
           origin[i].write_size_t(e)
         }
       end
-      region = FFI::MemoryPointer::new( :size_t, 3 )
+      region = MemoryPointer::new( :size_t, 3 )
       (0..2).each { |i| region[i].write_size_t(1) }
       if options[region_symbol] then
         options[region_symbol].each_with_index { |e, i|
@@ -218,11 +196,11 @@ module OpenCL
       return [origin, region]
     end
   
-    # Extracts the :properties named option (for a Context) from the hash given and returns an FFI:Pointer to a 0 terminated list of properties 
+    # Extracts the :properties named option (for a Context) from the hash given and returns an Pointer to a 0 terminated list of properties 
     def get_context_properties( options )
       properties = nil
       if options[:properties] then
-        properties = FFI::MemoryPointer::new( :cl_context_properties, options[:properties].length + 1 )
+        properties = MemoryPointer::new( :cl_context_properties, options[:properties].length + 1 )
         options[:properties].each_with_index { |e,i|
           properties[i].write_cl_context_properties(e.respond_to?(:to_ptr) ? e : e.to_i)
         }
@@ -231,7 +209,7 @@ module OpenCL
       return properties
     end
   
-    # Extracts the :device_list named option from the hash given and returns [ number of devices, an FFI:Pointer to the list of Device or nil ]
+    # Extracts the :device_list named option from the hash given and returns [ number of devices, an Pointer to the list of Device or nil ]
     def get_device_list( options )
       devices = options[:device_list]
       devices = [devices].flatten if devices
@@ -239,7 +217,7 @@ module OpenCL
       num_devices = 0
       if devices and devices.size > 0 then
         num_devices = devices.size
-        devices_p = FFI::MemoryPointer::new( Device, num_devices)
+        devices_p = MemoryPointer::new( Device, num_devices)
         devices_p.write_array_of_pointer(devices)
       end
       return [num_devices, devices_p]
@@ -313,10 +291,10 @@ module OpenCL
       klass_name = "MemObject" if klass == "Mem"
       s = <<EOF
       def #{name.downcase}
-        ptr1 = FFI::MemoryPointer::new( :size_t, 1)
+        ptr1 = MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name}, 0, nil, ptr1)
         error_check(error)
-        ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
+        ptr2 = MemoryPointer::new( ptr1.read_size_t )
         error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name}, ptr1.read_size_t, ptr2, nil)
         error_check(error)
         if(convert_type(:#{type})) then
@@ -335,13 +313,13 @@ EOF
       klass_name = "MemObject" if klass == "Mem"
       s = <<EOF
       def #{name.downcase}
-        ptr1 = FFI::MemoryPointer::new( :size_t, 1)
+        ptr1 = MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name}, 0, nil, ptr1)
         error_check(error)
-        ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
+        ptr2 = MemoryPointer::new( ptr1.read_size_t )
         error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name}, ptr1.read_size_t, ptr2, nil)
         error_check(error)
-        arr = ptr2.get_array_of_#{type}(0, ptr1.read_size_t/ FFI.find_type(:#{type}).size)
+        arr = ptr2.get_array_of_#{type}(0, ptr1.read_size_t/ OpenCL.find_type(:#{type}).size)
         return arr
       end
 EOF
@@ -353,3 +331,5 @@ EOF
   #:startdoc:
 
 end
+
+CL = OpenCL

data/lib/opencl_ruby_ffi/opencl_ruby_ffi_base_gen.rb

@@ -1,8 +1,6 @@
-require 'ffi'
-
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
 # Maps the OpenCL API using FFI
 module OpenCL
-  extend FFI::Library
   begin
     ffi_lib ENV["LIBOPENCL_SO"]
   rescue LoadError => e
@@ -2317,77 +2315,10 @@ module OpenCL
     CLASSES[-4] = MEM_OBJECT_ALLOCATION_FAILURE
     MemObjectAllocationFailure = MEM_OBJECT_ALLOCATION_FAILURE
   end
-  FFI.typedef :int8, :cl_char
-  FFI.typedef :uint8, :cl_uchar
-  FFI.typedef :int16, :cl_short
-  FFI.typedef :uint16, :cl_ushort
-  FFI.typedef :int32, :cl_int
-  FFI.typedef :uint32, :cl_uint
-  FFI.typedef :int64, :cl_long
-  FFI.typedef :uint64, :cl_ulong
-  FFI.typedef :uint16, :cl_half
-  FFI.typedef :float, :cl_float
-  FFI.typedef :double, :cl_double
-  FFI.typedef :uint32, :cl_GLuint
-  FFI.typedef :int32, :cl_GLint
-  FFI.typedef :uint32, :cl_GLenum
-  FFI.typedef :cl_uint, :cl_bool
-  FFI.typedef :cl_ulong, :cl_bitfield
-  FFI.typedef :cl_bitfield, :cl_device_type
-  FFI.typedef :cl_uint, :cl_platform_info
-  FFI.typedef :cl_uint, :cl_device_info
-  FFI.typedef :cl_bitfield, :cl_device_fp_config
-  FFI.typedef :cl_uint, :cl_device_mem_cache_type
-  FFI.typedef :cl_uint, :cl_device_local_mem_type
-  FFI.typedef :cl_bitfield, :cl_device_exec_capabilities
-  FFI.typedef :cl_bitfield, :cl_device_svm_capabilities
-  FFI.typedef :cl_bitfield, :cl_command_queue_properties
-  FFI.typedef :pointer, :cl_device_partition_property
-  FFI.typedef :cl_bitfield, :cl_device_affinity_domain
-  FFI.typedef :pointer, :cl_context_properties
-  FFI.typedef :cl_uint, :cl_context_info
-  FFI.typedef :cl_bitfield, :cl_queue_properties
-  FFI.typedef :cl_uint, :cl_command_queue_info
-  FFI.typedef :cl_uint, :cl_channel_order
-  FFI.typedef :cl_uint, :cl_channel_type
-  FFI.typedef :cl_bitfield, :cl_mem_flags
-  FFI.typedef :cl_bitfield, :cl_svm_mem_flags
-  FFI.typedef :cl_uint, :cl_mem_object_type
-  FFI.typedef :cl_uint, :cl_mem_info
-  FFI.typedef :cl_bitfield, :cl_mem_migration_flags
-  FFI.typedef :cl_uint, :cl_image_info
-  FFI.typedef :cl_uint, :cl_buffer_create_type
-  FFI.typedef :cl_uint, :cl_addressing_mode
-  FFI.typedef :cl_uint, :cl_filter_mode
-  FFI.typedef :cl_uint, :cl_sampler_info
-  FFI.typedef :cl_bitfield, :cl_map_flags
-  FFI.typedef :pointer, :cl_pipe_properties
-  FFI.typedef :cl_uint, :cl_pipe_info
-  FFI.typedef :cl_uint, :cl_program_info
-  FFI.typedef :cl_uint, :cl_program_build_info
-  FFI.typedef :cl_uint, :cl_program_binary_type
-  FFI.typedef :cl_int, :cl_build_status
-  FFI.typedef :cl_uint, :cl_kernel_info
-  FFI.typedef :cl_uint, :cl_kernel_arg_info
-  FFI.typedef :cl_uint, :cl_kernel_arg_address_qualifier
-  FFI.typedef :cl_uint, :cl_kernel_arg_access_qualifier
-  FFI.typedef :cl_bitfield, :cl_kernel_arg_type_qualifier
-  FFI.typedef :cl_uint, :cl_kernel_work_group_info
-  FFI.typedef :cl_uint, :cl_kernel_sub_group_info
-  FFI.typedef :cl_uint, :cl_event_info
-  FFI.typedef :cl_uint, :cl_command_type
-  FFI.typedef :cl_uint, :cl_profiling_info
-  FFI.typedef :cl_bitfield, :cl_sampler_properties
-  FFI.typedef :cl_uint, :cl_kernel_exec_info
-  FFI.typedef :cl_uint, :cl_gl_object_type
-  FFI.typedef :cl_uint, :cl_gl_texture_info
-  FFI.typedef :cl_uint, :cl_gl_platform_info
-  FFI.typedef :cl_uint, :cl_gl_context_info
-  FFI.typedef :cl_uint, :cl_queue_priority_khr
-  FFI.typedef :cl_uint, :cl_queue_throttle_khr
+
   # A parent class to represent OpenCL enums that use :cl_uint
   class Enum
-#    extend FFI::DataConverter
+#    extend DataConverter
 #    native_type :cl_uint
     class << self
       attr_reader :codes
@@ -2434,7 +2365,7 @@ module OpenCL
 
     # Enum should be considered an integer
     def coerce(other)
-      return [other, FFI::Pointer::new(self.to_i)] if other.is_a?(FFI::Pointer)
+      return [other, Pointer::new(self.to_i)] if other.is_a?(Pointer)
       return [other, self.to_i]
     end
 
@@ -2462,7 +2393,7 @@ module OpenCL
 #    end
 #
 #    def self.size
-#      FFI::find_type(:cl_uint).size
+#      find_type(:cl_uint).size
 #    end
 #
 #    def self.reference_required?
@@ -2474,13 +2405,13 @@ module OpenCL
 
   # A parent class to represent enums that use cl_int
   class EnumInt < Enum
-#    extend FFI::DataConverter
+#    extend DataConverter
 #    native_type :cl_int
   end
 
   # A parent class to represent OpenCL bitfields that use :cl_bitfield
   class Bitfield
-#    extend FFI::DataConverter
+#    extend DataConverter
 #    native_type :cl_bitfield
 
     # Initializes a new Bitfield to val
@@ -2559,7 +2490,7 @@ module OpenCL
 #    end
 #
 #    def self.size
-#      FFI::find_type(:cl_bitfield).size
+#      find_type(:cl_bitfield).size
 #    end
 #
 #    def self.reference_required?
@@ -2568,7 +2499,7 @@ module OpenCL
 #    #:startdoc:
 
   end
-  class Platform < FFI::ManagedStruct
+  class Platform < ManagedStruct
     layout :dummy, :pointer
     #:stopdoc:
     PROFILE = 0x0900
@@ -2600,7 +2531,7 @@ module OpenCL
   
   end
 
-  class Device < FFI::ManagedStruct
+  class Device < ManagedStruct
     layout :dummy, :pointer
     #:stopdoc:
     TYPE_DEFAULT = (1 << 0)
@@ -2732,7 +2663,7 @@ module OpenCL
     # Creates a new Device and retains it if specified and aplicable
     def initialize(ptr, retain = true)
       super(ptr)
-      platform = FFI::MemoryPointer::new( Platform )
+      platform = MemoryPointer::new( Platform )
       OpenCL.clGetDeviceInfo( ptr, OpenCL::Device::PLATFORM, platform.size, platform, nil)
       p = OpenCL::Platform::new(platform.read_pointer)
       if p.version_number >= 1.2 and retain then
@@ -2744,7 +2675,7 @@ module OpenCL
   
     # method called at Device deletion, releases the object if aplicable
     def self.release(ptr)
-      platform = FFI::MemoryPointer::new( Platform )
+      platform = MemoryPointer::new( Platform )
       OpenCL.clGetDeviceInfo( ptr, OpenCL::Device::PLATFORM, platform.size, platform, nil)
       p = OpenCL::Platform::new(platform.read_pointer)
       if p.version_number >= 1.2 then
@@ -2889,7 +2820,7 @@ module OpenCL
     end
 
   end
-  class Context < FFI::ManagedStruct
+  class Context < ManagedStruct
     layout :dummy, :pointer
     #:stopdoc:
     REFERENCE_COUNT = 0x1080
@@ -2911,7 +2842,7 @@ module OpenCL
     # method called at Context deletion, releases the object if aplicable
     def self.release(ptr)
       #STDERR.puts "Releasing Context: #{ptr}"
-      #ref_count = FFI::MemoryPointer::new( :cl_uint ) 
+      #ref_count = MemoryPointer::new( :cl_uint ) 
       #OpenCL.clGetContextInfo(ptr, OpenCL::Context::REFERENCE_COUNT, ref_count.size, ref_count, nil)
       #STDERR.puts "reference counter: #{ref_count.read_cl_uint}"
       error = OpenCL.clReleaseContext(ptr)
@@ -2964,7 +2895,7 @@ module OpenCL
     end
   end
 
-  class CommandQueue < FFI::ManagedStruct
+  class CommandQueue < ManagedStruct
     layout :dummy, :pointer
     #:stopdoc:
     OUT_OF_ORDER_EXEC_MODE_ENABLE = (1 << 0)
@@ -2995,7 +2926,7 @@ module OpenCL
     # method called at CommandQueue deletion, releases the object if aplicable
     def self.release(ptr)
       #STDERR.puts "Releasing CommandQueue: #{ptr}"
-      #ref_count = FFI::MemoryPointer::new( :cl_uint ) 
+      #ref_count = MemoryPointer::new( :cl_uint ) 
       #OpenCL.clGetCommandQueueInfo(ptr, OpenCL::CommandQueue::REFERENCE_COUNT, ref_count.size, ref_count, nil)
       #STDERR.puts "reference counter: #{ref_count.read_cl_uint}"
       error = OpenCL.clReleaseCommandQueue(ptr)
@@ -3050,7 +2981,7 @@ module OpenCL
       @codes[(1 << 2)] = 'THROTTLE_LOW_KHR'
     end
   end
-  class Mem < FFI::ManagedStruct
+  class Mem < ManagedStruct
     layout :dummy, :pointer
     #:stopdoc:
     READ_WRITE = (1 << 0)
@@ -3099,7 +3030,7 @@ module OpenCL
     # method called at Mem deletion, releases the object if aplicable
     def self.release(ptr)
       #STDERR.puts "Releasing Mem: #{ptr}"
-      #ref_count = FFI::MemoryPointer::new( :cl_uint ) 
+      #ref_count = MemoryPointer::new( :cl_uint ) 
       #OpenCL.clGetMemObjectInfo(ptr, OpenCL::Mem::REFERENCE_COUNT, ref_count.size, ref_count, nil)
       #STDERR.puts "reference counter: #{ref_count.read_cl_uint}"
       error = OpenCL.clReleaseMemObject(ptr)
@@ -3196,7 +3127,7 @@ module OpenCL
     end
 
   end
-  class Program < FFI::ManagedStruct
+  class Program < ManagedStruct
     layout :dummy, :pointer
     #:stopdoc:
     REFERENCE_COUNT = 0x1160
@@ -3230,7 +3161,7 @@ module OpenCL
     # method called at Program deletion, releases the object if aplicable
     def self.release(ptr)
       #STDERR.puts "Releasing Program: #{ptr}"
-      #ref_count = FFI::MemoryPointer::new( :cl_uint ) 
+      #ref_count = MemoryPointer::new( :cl_uint ) 
       #OpenCL.clGetProgramInfo(ptr, OpenCL::Program::REFERENCE_COUNT, ref_count.size, ref_count, nil)
       #STDERR.puts "reference counter: #{ref_count.read_cl_uint}"
       error = OpenCL.clReleaseProgram(ptr)
@@ -3266,7 +3197,7 @@ module OpenCL
     end
 
   end
-  class Kernel < FFI::ManagedStruct
+  class Kernel < ManagedStruct
     layout :dummy, :pointer
     #:stopdoc:
     FUNCTION_NAME = 0x1190
@@ -3317,7 +3248,7 @@ module OpenCL
     # method called at Kernel deletion, releases the object if aplicable
     def self.release(ptr)
       #STDERR.puts "Releasing Kernel: #{ptr}"
-      #ref_count = FFI::MemoryPointer::new( :cl_uint ) 
+      #ref_count = MemoryPointer::new( :cl_uint ) 
       #OpenCL.clGetKernelInfo(ptr, OpenCL::Kernel::REFERENCE_COUNT, ref_count.size, ref_count, nil)
       #STDERR.puts "reference counter: #{ref_count.read_cl_uint}"
       error = OpenCL.clReleaseKernel(ptr)
@@ -3405,7 +3336,7 @@ module OpenCL
 
     end
   end
-  class Event < FFI::ManagedStruct
+  class Event < ManagedStruct
     layout :dummy, :pointer
     #:stopdoc:
     COMMAND_QUEUE = 0x11D0
@@ -3424,7 +3355,7 @@ module OpenCL
     # method called at Event deletion, releases the object if aplicable
     def self.release(ptr)
       #STDERR.puts "Releasing Event: #{ptr}"
-      #ref_count = FFI::MemoryPointer::new( :cl_uint ) 
+      #ref_count = MemoryPointer::new( :cl_uint ) 
       #OpenCL.clGetEventInfo(ptr, OpenCL::Event::REFERENCE_COUNT, ref_count.size, ref_count, nil)
       #STDERR.puts "reference counter: #{ref_count.read_cl_uint}"
       error = OpenCL.clReleaseEvent(ptr)
@@ -3443,7 +3374,7 @@ module OpenCL
   
   end
 
-  class Sampler < FFI::ManagedStruct
+  class Sampler < ManagedStruct
     layout :dummy, :pointer
     #:stopdoc:
     REFERENCE_COUNT = 0x1150
@@ -3465,7 +3396,7 @@ module OpenCL
     # method called at Sampler deletion, releases the object if aplicable
     def self.release(ptr)
       #STDERR.puts "Releasing Sampler: #{ptr}"
-      #ref_count = FFI::MemoryPointer::new( :cl_uint ) 
+      #ref_count = MemoryPointer::new( :cl_uint ) 
       #OpenCL.clGetSamplerInfo(ptr, OpenCL::Sampler::REFERENCE_COUNT, ref_count.size, ref_count, nil)
       #STDERR.puts "reference counter: #{ref_count.read_cl_uint}"
       error = OpenCL.clReleaseSampler(ptr)
@@ -3483,7 +3414,7 @@ module OpenCL
     end
   
   end
-  class GLsync < FFI::ManagedStruct
+  class GLsync < ManagedStruct
     layout :dummy, :pointer
     #:stopdoc:
     
@@ -3928,13 +3859,13 @@ module OpenCL
         attach_function :clCloneKernel, [Kernel,:pointer], Kernel
         attach_function :clGetKernelSubGroupInfo, [Kernel,Device,:cl_kernel_sub_group_info,:size_t,:pointer,:size_t,:pointer,:pointer], :cl_int
         attach_function :clEnqueueSVMMigrateMem, [CommandQueue,:cl_uint,:pointer,:pointer,:cl_mem_migration_flags,:cl_uint,:pointer,:pointer], :cl_int
-      rescue FFI::NotFoundError => e
+      rescue NotFoundError => e
         warn "Warning OpenCL 2.0 loader detected!"
       end
-    rescue FFI::NotFoundError => e
+    rescue NotFoundError => e
       warn "Warning OpenCL 1.2 loader detected!"
     end
-  rescue FFI::NotFoundError => e
+  rescue NotFoundError => e
     warn "Warning OpenCL 1.1 loader detected!"
   end
 end

data/lib/opencl_ruby_ffi/opencl_types.rb

@@ -0,0 +1,114 @@
+require 'ffi'
+
+module OpenCL
+  include FFI
+  extend Library
+
+  TYPES = [
+    [ :int8, :cl_char ],
+    [ :uint8, :cl_uchar ],
+    [ :int16, :cl_short ],
+    [ :uint16, :cl_ushort ],
+    [ :int32, :cl_int ],
+    [ :uint32, :cl_uint ],
+    [ :int64, :cl_long ],
+    [ :uint64, :cl_ulong ],
+    [ :uint16, :cl_half ],
+    [ :float, :cl_float ],
+    [ :double, :cl_double ],
+    [ :uint32, :cl_GLuint ],
+    [ :int32, :cl_GLint ],
+    [ :uint32, :cl_GLenum ],
+    [ :cl_uint, :cl_bool ],
+    [ :cl_ulong, :cl_bitfield ],
+    [ :cl_bitfield, :cl_device_type ],
+    [ :cl_uint, :cl_platform_info ],
+    [ :cl_uint, :cl_device_info ],
+    [ :cl_bitfield, :cl_device_fp_config ],
+    [ :cl_uint, :cl_device_mem_cache_type ],
+    [ :cl_uint, :cl_device_local_mem_type ],
+    [ :cl_bitfield, :cl_device_exec_capabilities ],
+    [ :cl_bitfield, :cl_device_svm_capabilities ],
+    [ :cl_bitfield, :cl_command_queue_properties ],
+    [ :pointer, :cl_device_partition_property ],
+    [ :cl_bitfield, :cl_device_affinity_domain ],
+    [ :pointer, :cl_context_properties ],
+    [ :cl_uint, :cl_context_info ],
+    [ :cl_bitfield, :cl_queue_properties ],
+    [ :cl_uint, :cl_command_queue_info ],
+    [ :cl_uint, :cl_channel_order ],
+    [ :cl_uint, :cl_channel_type ],
+    [ :cl_bitfield, :cl_mem_flags ],
+    [ :cl_bitfield, :cl_svm_mem_flags ],
+    [ :cl_uint, :cl_mem_object_type ],
+    [ :cl_uint, :cl_mem_info ],
+    [ :cl_bitfield, :cl_mem_migration_flags ],
+    [ :cl_uint, :cl_image_info ],
+    [ :cl_uint, :cl_buffer_create_type ],
+    [ :cl_uint, :cl_addressing_mode ],
+    [ :cl_uint, :cl_filter_mode ],
+    [ :cl_uint, :cl_sampler_info ],
+    [ :cl_bitfield, :cl_map_flags ],
+    [ :pointer, :cl_pipe_properties ],
+    [ :cl_uint, :cl_pipe_info ],
+    [ :cl_uint, :cl_program_info ],
+    [ :cl_uint, :cl_program_build_info ],
+    [ :cl_uint, :cl_program_binary_type ],
+    [ :cl_int, :cl_build_status ],
+    [ :cl_uint, :cl_kernel_info ],
+    [ :cl_uint, :cl_kernel_arg_info ],
+    [ :cl_uint, :cl_kernel_arg_address_qualifier ],
+    [ :cl_uint, :cl_kernel_arg_access_qualifier ],
+    [ :cl_bitfield, :cl_kernel_arg_type_qualifier ],
+    [ :cl_uint, :cl_kernel_work_group_info ],
+    [ :cl_uint, :cl_kernel_sub_group_info ],
+    [ :cl_uint, :cl_event_info ],
+    [ :cl_uint, :cl_command_type ],
+    [ :cl_uint, :cl_profiling_info ],
+    [ :cl_bitfield, :cl_sampler_properties ],
+    [ :cl_uint, :cl_kernel_exec_info ],
+    [ :cl_uint, :cl_gl_object_type ],
+    [ :cl_uint, :cl_gl_texture_info ],
+    [ :cl_uint, :cl_gl_platform_info ],
+    [ :cl_uint, :cl_gl_context_info ],
+    [ :cl_uint, :cl_queue_priority_khr ],
+    [ :cl_uint, :cl_queue_throttle_khr ]
+  ]
+  
+  TYPES.each { |orig, add|
+    typedef orig, add
+  }
+  TYPES.push [ FFI::TypeDefs.find { |name,t| t == FFI.find_type(:size_t) }.first, :size_t]
+end
+
+if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+  module OpenCLRefinements
+
+    refine FFI::Pointer do
+      methods_prefix = [:put, :get, :write, :read, :put_array_of, :get_array_of]
+      OpenCL::TYPES.each { |orig, add|
+        methods_prefix.each { |meth|
+          alias_method "#{meth}_#{add}".to_sym, "#{meth}_#{orig}".to_sym
+        }
+      }
+    end
+
+  end
+  using OpenCLRefinements
+else
+
+  class FFI::Pointer
+    methods_prefix = [:put, :get, :write, :read, :put_array_of, :get_array_of]
+    OpenCL::TYPES.each { |orig, add|
+      methods_prefix.each { |meth|
+        alias_method "#{meth}_#{add}".to_sym, "#{meth}_#{orig}".to_sym
+      }
+    }
+  end
+
+end
+
+module OpenCL
+  remove_const(:TYPES)
+end

data/lib/opencl_ruby_ffi.rb

@@ -1,6 +1,7 @@
+require "opencl_ruby_ffi/opencl_types.rb"
 require "opencl_ruby_ffi/opencl_ruby_ffi_base_gen.rb"
+require "opencl_ruby_ffi/opencl_arithmetic_gen.rb"
 require "opencl_ruby_ffi/opencl_ruby_ffi_base.rb"
-require "opencl_ruby_ffi/Arithmetic_gen.rb"
 require "opencl_ruby_ffi/Context.rb"
 require "opencl_ruby_ffi/Platform.rb"
 require "opencl_ruby_ffi/Device.rb"

data/opencl_ruby_ffi.gemspec

@@ -1,12 +1,12 @@
 Gem::Specification.new do |s|
   s.name = 'opencl_ruby_ffi'
-  s.version = "1.1.0"
+  s.version = "1.2.0"
   s.author = "Brice Videau"
   s.email = "brice.videau@imag.fr"
   s.homepage = "https://github.com/Nanosim-LIG/opencl-ruby"
   s.summary = "Ruby OpenCL FFI bindings"
   s.description = "Ruby OpenCL FFI bindings. OpenCL 2.1 ready"
-  s.files = %w( opencl_ruby_ffi.gemspec LICENSE lib/opencl_ruby_ffi.rb lib/opencl_ruby_ffi/ lib/opencl_ruby_ffi/Arithmetic_gen.rb lib/opencl_ruby_ffi/Buffer.rb lib/opencl_ruby_ffi/CommandQueue.rb lib/opencl_ruby_ffi/Context.rb lib/opencl_ruby_ffi/Device.rb lib/opencl_ruby_ffi/Event.rb lib/opencl_ruby_ffi/Image.rb lib/opencl_ruby_ffi/Kernel.rb lib/opencl_ruby_ffi/Mem.rb lib/opencl_ruby_ffi/opencl_ruby_ffi_base_gen.rb lib/opencl_ruby_ffi/opencl_ruby_ffi_base.rb lib/opencl_ruby_ffi/Platform.rb lib/opencl_ruby_ffi/Program.rb lib/opencl_ruby_ffi/Sampler.rb lib/opencl_ruby_ffi/Pipe.rb lib/opencl_ruby_ffi/SVM.rb lib/opencl_ruby_ffi/GLExt.rb )
+  s.files =  Dir[ 'opencl_ruby_ffi.gemspec', 'LICENSE', 'lib/**/*']
   s.has_rdoc = true
   s.license = 'BSD'
   s.required_ruby_version = '>= 1.8.7'