opencl_ruby_ffi 0.3 → 0.4

data/lib/opencl_ruby_ffi/Program.rb

@@ -11,29 +11,176 @@ module OpenCL
   # ==== Options
   #
   # * +:device_list+ - an Array of Device to build the program for
-  # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
   # * +:options+ - a String containing the options to use for the build
+  # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
   def self.build_program(program, options = {}, &block)
     @@callbacks.push( block ) if block
+    devices = options[:device_list]
+    devices = [devices].flatten if devices
+    devices_p = nil
+    num_devices = 0
+    if devices and devices.size > 0 then
+      num_devices = devices.size
+      devices_p = FFI::MemoryPointer::new( Device, num_devices)
+      num_devices.times { |indx|
+        devices_p[indx].write_pointer(devices[indx])
+      }
+    end
+    opt = ""
+    opt = options[:options] if options[:options]
+    options_p = FFI::MemoryPointer.from_string(opt)
+    error = OpenCL.clBuildProgram(program, num_devices, devices_p, options_p, block, options[:user_data] )
+    OpenCL.error_check(error)
+    return program
+  end
+
+  # Links a set of compiled programs for all device in a Context, or a subset of devices
+  #
+  # ==== Attributes
+  #
+  # * +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| ... }
+  #
+  # ==== Options
+  #
+  # * +:device_list+ - an Array of Device to build the program for
+  # * +:options+ - a String containing the options to use for the build
+  # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
+  def self.link_program(context, input_programs, options = {}, &block)
+    @@callbacks.push( block ) if block
+    devices = options[:device_list]
+    devices = [devices].flatten if devices
+    devices_p = nil
+    num_devices = 0
+    if devices and devices.size > 0 then
+      num_devices = devices.size
+      devices_p = FFI::MemoryPointer::new( Device, num_devices)
+      num_devices.times { |indx|
+        devices_p[indx].write_pointer(devices[indx])
+      }
+    end
     opt = ""
     opt = options[:options] if options[:options]
     options_p = FFI::MemoryPointer.from_string(opt)
+    programs = [input_programs].flatten
+    num_programs = programs.length
+    programs_p = FFI::MemoryPointer::new( Program, num_programs )
+    programs.each_with_index { |e, i|
+      programs_p[i].write_pointer(e)
+    }
+    error = FFI::MemoryPointer::new( :cl_int )
+    prog = OpenCL.clLinkProgram( context, num_devices, devices_p, options_p, num_programs, programs_p, block, options[:user_data], error)
+    OpenCL.error_check(error.read_cl_int)
+    return OpenCL::Program::new( prog, false )
+  end
+
+  # Compiles a Program created from sources
+  #
+  # ==== Attributes
+  #
+  # * +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| ... }
+  #
+  # ==== Options
+  #
+  # * +:device_list+ - an Array of Device to build the program for
+  # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
+  # * +:options+ - a String containing the options to use for the compilation
+  # * +:input_headers+ - a Hash containing pairs of : String: header_include_name => Program: header
+  def self.compile_program(program, options = {}, &block)
+    @@callback.push( block ) if block
     devices = options[:device_list]
     devices = [devices].flatten if devices
     devices_p = nil
     num_devices = 0
     if devices and devices.size > 0 then
       num_devices = devices.size
-      devices_p = FFI::MemoryPointer.new( Device, num_devices)
+      devices_p = FFI::MemoryPointer::new( Device, num_devices)
       num_devices.times { |indx|
-        devices_p.put_pointer(indx, devices[indx])
+        devices_p[indx].write_pointer(devices[indx])
+      }
+    end
+    opt = ""
+    opt = options[:options] if options[:options]
+    options_p = FFI::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 )
+      indx = 0
+      headers.each { |key, value|
+        headers_p[indx].write_pointer(value)
+        header_include_names[indx] = FFI::MemoryPointer.from_string(key)
+        indx = indx + 1
       }
     end
-    err = OpenCL.clBuildProgram(program, num_devices, devices_p, options_p, block, options[:user_data] )
-    OpenCL.error_check(err)
+    error = OpenCL.clCompileProgram(program, num_devices, devices_p, options_p, num_headers, headers_p, header_include_names, block, options[:user_data] )
+    OpenCL.error_check(error)
     return program
   end
 
+  # Creates a Program from a list of built in kernel names
+  #
+  # ==== Attributes
+  #
+  # * +context+ - Context the created Program will be associated to
+  # * +device_list+ - an Array of Device to create the program for
+  # * +kernel_names+ - a single or an Array of String representing the kernel names
+  def self.create_program_with_built_in_kernels(context, device_list, kernel_names)
+    devices = [device_list].flatten
+    num_devices = devices.length
+    devices_p = FFI::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 )
+    prog = OpenCL.clCreateProgramWithBuiltInKernels( context, num_devices, devices_p, names_p, error )
+    OpenCL.error_check(error.read_cl_int)
+    return OpenCL::Program::new(prog, false)
+  end
+
+  # Creates a Program from binary
+  #
+  # ==== Attributes
+  #
+  # * +context+ - Context the created Program will be associated to
+  # * +device_list+ - an Array of Device to create the program for. Can throw an OpenCL::Invalid value if the number of supplied devices is different from the number of supplied binaries.
+  # * +binaries+ - Array of binaries 
+  def self.create_program_with_binary(context, device_list, binaries)
+    bins = [binaries].flatten
+    num_devices = bins.length
+    devices = [device_list].flatten
+    OpenCL.error_check(OpenCL::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 )
+    num_devices.times { |indx|
+      devices_p[indx].write_pointer(devices[indx])
+      lengths[indx].write_size_t(binaries[indx].size)
+      p = FFI::MemoryPointer::new(binaries[indx].size)
+      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 )
+    prog = OpenCL.clCreateProgramWithBinary(context, num_devices, devices_p, lengths, binaries_p, binary_status, error)
+    OpenCL.error_check(error.read_cl_int)
+    d_s = []
+    num_devices.times { |indx|
+      d_s.push [ devices[indx], binary_status[indx].read_cl_int ]
+    }
+    return [ OpenCL::Program::new(prog, false), d_s ]
+  end
+
   # Creates a Program from sources
   #
   # ==== Attributes
@@ -48,8 +195,8 @@ 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 = FFI::MemoryPointer::new( :size_t, n_strs )
+    c_strs = FFI::MemoryPointer::new( :pointer, n_strs )
 
     c_strs_p = []
     strs.each { |str|
@@ -59,13 +206,13 @@ module OpenCL
     }
     raise OpenCL::Error::new(OpenCL::Error.getErrorString(OpenCL::Error::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 = FFI::MemoryPointer::new( :pointer, c_strs_p.size )
+    c_strs_length = FFI::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)
     }
-    pointer_err = FFI::MemoryPointer.new( :cl_int )
+    pointer_err = FFI::MemoryPointer::new( :cl_int )
     program_ptr = OpenCL.clCreateProgramWithSource(context, c_strs_p.size, c_strs, c_strs_length, pointer_err)
     OpenCL.error_check(pointer_err.read_cl_int)
     return OpenCL::Program::new( program_ptr, false )
@@ -88,9 +235,10 @@ module OpenCL
       if k then
         k.enqueue_with_args(*a, &b)
       else
-        orig_method_missing(m, *args, &b)
+        orig_method_missing(m, *a, &b)
       end
     end
+
     # Returns an Array containing the sizes of the binary inside the Program for each device
     eval OpenCL.get_info_array("Program", :size_t, "BINARY_SIZES")
 
@@ -99,10 +247,10 @@ module OpenCL
 
     # Returns an Array of String representing the Kernel names inside the Program
     def kernel_names
-      kernel_names_size = FFI::MemoryPointer.new( :size_t )
+      kernel_names_size = FFI::MemoryPointer::new( :size_t )
       error = OpenCL.clGetProgramInfo( self, OpenCL::Program::KERNEL_NAMES, 0, nil, kernel_names_size)
       OpenCL.error_check(error)
-      k_names = FFI::MemoryPointer.new( kernel_names_size.read_size_t )
+      k_names = FFI::MemoryPointer::new( kernel_names_size.read_size_t )
       error = OpenCL.clGetProgramInfo( self, OpenCL::Program::KERNEL_NAMES, kernel_names_size.read_size_t, k_names, nil)
       OpenCL.error_check(error)
       k_names_string = k_names.read_string
@@ -112,11 +260,11 @@ module OpenCL
     # Returns the concatenated Program sources
     eval OpenCL.get_info("Program", :string, "SOURCE")
 
-    # Returns the BuildStatus of the  Program
+    # Returns the BuildStatus of the Program for each device associated to the Program or the Device(s) specified. Returns an Array of tuple [ Device, BuildStatus ]
     def build_status(devs = nil)
       devs = self.devices if not devs
       devs = [devs].flatten
-      ptr = FFI::MemoryPointer.new( :cl_build_status )
+      ptr = FFI::MemoryPointer::new( :cl_build_status )
       return devs.collect { |dev|
         error = OpenCL.clGetProgramBuildInfo(self, dev, OpenCL::Program::BUILD_STATUS, ptr.size, ptr, nil)
         OpenCL.error_check(error)
@@ -124,11 +272,11 @@ module OpenCL
       }
     end
 
-    # Returns the BinaryType for each Device associated to the Program or the Device specified
+    # Returns the BinaryType for each Device associated to the Program or the Device(s) specified. Returns an Array of tuple [ Device, BinaryType ]
     def binary_type(devs = nil)
       devs = self.devices if not devs
       devs = [devs].flatten
-      ptr = FFI::MemoryPointer.new( :cl_program_binary_type )
+      ptr = FFI::MemoryPointer::new( :cl_program_binary_type )
       return devs.collect { |dev|
         error = OpenCL.clGetProgramBuildInfo(self, dev, OpenCL::Program::BINARY_TYPE, ptr.size, ptr, nil)
         OpenCL.error_check(error)
@@ -136,45 +284,45 @@ module OpenCL
       }
     end
 
-    # Returns the build options for each Device associated to the Program or the Device specified
+    # Returns the build options for each Device associated to the Program or the Device(s) specified. Returns an Array of tuple [ Device, String ]
     def build_options(devs = nil)
       devs = self.devices if not devs
       devs = [devs].flatten
       return devs.collect { |dev|
-        ptr1 = FFI::MemoryPointer.new( :size_t, 1)
+        ptr1 = FFI::MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGetProgramBuildInfo(self, dev, OpenCL::Program::BUILD_OPTIONS, 0, nil, ptr1)
         OpenCL.error_check(error)
-        ptr2 = FFI::MemoryPointer.new( ptr1.read_size_t )
+        ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
         error = OpenCL.clGetProgramBuildInfo(self, dev, OpenCL::Program::BUILD_OPTIONS, ptr1.read_size_t, ptr2, nil)
         OpenCL.error_check(error)
         [dev, ptr2.read_string]
       }
     end
 
-    # Returns the build log for each Device associated to the Program or the Device specified
+    # Returns the build log for each Device associated to the Program or the Device(s) specified. Returns an Array of tuple [ Device, String ]
     def build_log(devs = nil)
       devs = self.devices if not devs
       devs = [devs].flatten
       return devs.collect { |dev|
-        ptr1 = FFI::MemoryPointer.new( :size_t, 1)
+        ptr1 = FFI::MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGetProgramBuildInfo(self, dev, OpenCL::Program::BUILD_LOG, 0, nil, ptr1)
         OpenCL.error_check(error)
-        ptr2 = FFI::MemoryPointer.new( ptr1.read_size_t )
+        ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
         error = OpenCL.clGetProgramBuildInfo(self, dev, OpenCL::Program::BUILD_LOG, ptr1.read_size_t, ptr2, nil)
         OpenCL.error_check(error)
         [dev, ptr2.read_string]
       }
     end
 
-    # Returns the binaries associated to the Program for each Device
+    # 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 = FFI::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(FFI::MemoryPointer::new(s))
       }
       error = OpenCL.clGetProgramInfo(self, Program::BINARIES, total_size, bin_array, nil)
       OpenCL.error_check(error)
@@ -191,7 +339,7 @@ module OpenCL
     # ==== Attributes
     #
     # * +options+ - a hash containing named options
-    # * +block+ - if provided, a callback invoked when error arise in the context. 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, FFI::Pointer to user_data| ... }
     #
     # ==== Options
     # * +:device_list+ - an Array of Device to build the program for
@@ -201,9 +349,26 @@ module OpenCL
       OpenCL.build_program(self, options, &block)
     end
 
+    # Compiles the Program' sources
+    #
+    # ==== 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| ... }
+    #
+    # ==== Options
+    #
+    # * +:device_list+ - an Array of Device to build the program for
+    # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
+    # * +:options+ - a String containing the options to use for the compilation
+    # * +:input_headers+ - a Hash containing pairs of : String: header_include_name => Program: header
+    def compile(options = {}, &block)
+      return OpenCL.compile_program(self, options, &block)
+    end
+
     # Returns the Context the Program is associated to
     def context
-      ptr = FFI::MemoryPointer.new( Context )
+      ptr = FFI::MemoryPointer::new( Context )
       error = OpenCL.clGetProgramInfo(self, Program::CONTEXT, Context.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Context::new( ptr.read_pointer )
@@ -223,11 +388,11 @@ 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 = FFI::MemoryPointer::new( Device, n )
       error = OpenCL.clGetProgramInfo(self, Program::DEVICES, Device.size*n, ptr2, nil)
       OpenCL.error_check(error)
       return ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
-        OpenCL::Device.new(device_ptr)
+        OpenCL::Device::new(device_ptr)
       }
     end
 

data/lib/opencl_ruby_ffi/Sampler.rb

@@ -20,7 +20,7 @@ module OpenCL
 
     # Returns the context associated with the Sampler
     def context
-      ptr = FFI::MemoryPointer.new( Context )
+      ptr = FFI::MemoryPointer::new( Context )
       error = OpenCL.clGetSamplerInfo(self, Sampler::CONTEXT, Context.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Context::new( ptr.read_pointer )

data/lib/opencl_ruby_ffi/opencl_ruby_ffi_base.rb

@@ -184,7 +184,7 @@ module OpenCL
     if options[:event_wait_list] then
       num_events = options[:event_wait_list].length
       if num_events > 0 then
-        events = FFI::MemoryPointer.new( Event, num_events )
+        events = FFI::MemoryPointer::new( Event, num_events )
         options[:event_wait_list].each_with_index { |e, i|
           events[i].write_pointer(e)
         }
@@ -208,14 +208,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 self.get_origin_region( image, options, origin_symbol, region_symbol )
-    origin = FFI::MemoryPointer.new( :size_t, 3 )
+    origin = FFI::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 = FFI::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|
@@ -241,7 +241,7 @@ module OpenCL
   def self.get_context_properties( options )
     properties = nil
     if options[:properties] then
-      properties = FFI::MemoryPointer.new( :cl_context_properties, options[:properties].length + 1 )
+      properties = FFI::MemoryPointer::new( :cl_context_properties, options[:properties].length + 1 )
       options[:properties].each_with_index { |e,i|
         properties[i].write_cl_context_properties(e)
       }
@@ -261,7 +261,7 @@ module OpenCL
     klass_name = "MemObject" if klass == "Mem"
     s = <<EOF
       def #{name.downcase}
-        ptr1 = FFI::MemoryPointer.new( :size_t, 1)
+        ptr1 = FFI::MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name}, 0, nil, ptr1)
         OpenCL.error_check(error)
 EOF
@@ -271,7 +271,7 @@ EOF
 EOF
     end
     s += <<EOF
-        ptr2 = FFI::MemoryPointer.new( ptr1.read_size_t )
+        ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
         error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name}, ptr1.read_size_t, ptr2, nil)
         OpenCL.error_check(error)
         arr = ptr2.get_array_of_#{type}(0, ptr1.read_size_t/ FFI.find_type(:#{type}).size)
@@ -296,10 +296,10 @@ EOF
     klass_name = "MemObject" if klass == "Mem"
     s = <<EOF
       def #{name.downcase}
-        ptr1 = FFI::MemoryPointer.new( :size_t, 1)
+        ptr1 = FFI::MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name}, 0, nil, ptr1)
         OpenCL.error_check(error)
-        ptr2 = FFI::MemoryPointer.new( ptr1.read_size_t )
+        ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
         error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name}, ptr1.read_size_t, ptr2, nil)
         OpenCL.error_check(error)
 EOF

data/lib/opencl_ruby_ffi/opencl_ruby_ffi_base_gen.rb

@@ -724,6 +724,14 @@ module OpenCL
       #STDERR.puts "Allocating Platform: #{ptr}"
     end
   
+    def to_s
+      if self.respond_to?(:name) then
+        return self.name
+      else
+        return super
+      end
+    end
+  
     # method called at Platform deletion, releases the object if aplicable
     def self.release(ptr)
     end
@@ -853,11 +861,33 @@ 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 )
+      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
+        error = OpenCL.clRetainDevice(ptr)
+        OpenCL.error_check( error )
+      end
       #STDERR.puts "Allocating Device: #{ptr}"
     end
   
+    def to_s
+      if self.respond_to?(:name) then
+        return self.name
+      else
+        return super
+      end
+    end
+  
     # method called at Device deletion, releases the object if aplicable
     def self.release(ptr)
+      platform = FFI::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
+        error = OpenCL.clReleaseDevice(ptr)
+        OpenCL.error_check( error )
+      end
     end
   end
 
@@ -994,10 +1024,18 @@ module OpenCL
       #STDERR.puts "Allocating Context: #{ptr}"
     end
   
+    def to_s
+      if self.respond_to?(:name) then
+        return self.name
+      else
+        return super
+      end
+    end
+  
     # 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 = FFI::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)
@@ -1024,10 +1062,18 @@ module OpenCL
       #STDERR.puts "Allocating CommandQueue: #{ptr}"
     end
   
+    def to_s
+      if self.respond_to?(:name) then
+        return self.name
+      else
+        return super
+      end
+    end
+  
     # 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 = FFI::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)
@@ -1097,10 +1143,18 @@ module OpenCL
       #STDERR.puts "Allocating Mem: #{ptr}"
     end
   
+    def to_s
+      if self.respond_to?(:name) then
+        return self.name
+      else
+        return super
+      end
+    end
+  
     # 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 = FFI::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)
@@ -1204,10 +1258,18 @@ module OpenCL
       #STDERR.puts "Allocating Program: #{ptr}"
     end
   
+    def to_s
+      if self.respond_to?(:name) then
+        return self.name
+      else
+        return super
+      end
+    end
+  
     # 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 = FFI::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)
@@ -1278,10 +1340,18 @@ module OpenCL
       #STDERR.puts "Allocating Kernel: #{ptr}"
     end
   
+    def to_s
+      if self.respond_to?(:name) then
+        return self.name
+      else
+        return super
+      end
+    end
+  
     # 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 = FFI::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)
@@ -1390,10 +1460,18 @@ module OpenCL
       #STDERR.puts "Allocating Event: #{ptr}"
     end
   
+    def to_s
+      if self.respond_to?(:name) then
+        return self.name
+      else
+        return super
+      end
+    end
+  
     # 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 = FFI::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)
@@ -1419,10 +1497,18 @@ module OpenCL
       #STDERR.puts "Allocating Sampler: #{ptr}"
     end
   
+    def to_s
+      if self.respond_to?(:name) then
+        return self.name
+      else
+        return super
+      end
+    end
+  
     # 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 = FFI::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)
@@ -1443,6 +1529,14 @@ module OpenCL
       #STDERR.puts "Allocating GLsync: #{ptr}"
     end
   
+    def to_s
+      if self.respond_to?(:name) then
+        return self.name
+      else
+        return super
+      end
+    end
+  
     # method called at GLsync deletion, releases the object if aplicable
     def self.release(ptr)
     end

data/opencl_ruby_ffi.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'opencl_ruby_ffi'
-  s.version = "0.3"
+  s.version = "0.4"
   s.author = "Brice Videau"
   s.email = "brice.videau@imag.fr"
   s.homepage = "https://forge.imag.fr/projects/opencl-ruby/"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opencl_ruby_ffi
 version: !ruby/object:Gem::Version
-  version: '0.3'
+  version: '0.4'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-23 00:00:00.000000000 Z
+date: 2014-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray