opencl_ruby_ffi 0.994 → 0.995

data/lib/opencl_ruby_ffi/Mem.rb

@@ -20,13 +20,18 @@ module OpenCL
 
   # Maps the cl_mem object of OpenCL
   class Mem
+    include InnerInterface
+
+    class << self
+      include InnerGenerator
+    end
 
     # Returns the Context associated to the Mem
     def context
       ptr = FFI::MemoryPointer::new( Context )
       error = OpenCL.clGetMemObjectInfo(self, CONTEXT, Context.size, ptr, nil)
-      OpenCL.error_check(error)
-      return OpenCL::Context::new( ptr.read_pointer )
+      error_check(error)
+      return Context::new( ptr.read_pointer )
     end
 
     # Returns the Platform associated to the Mem
@@ -38,7 +43,7 @@ module OpenCL
     def associated_memobject
       ptr = FFI::MemoryPointer::new( Mem )
       error = OpenCL.clGetMemObjectInfo(self, ASSOCIATED_MEMOBJECT, Mem.size, ptr, nil)
-      OpenCL.error_check(error)
+      error_check(error)
       return nil if ptr.read_pointer.null?
       return Mem::new( ptr.read_pointer )
     end
@@ -51,7 +56,7 @@ module OpenCL
     # :method: size()
     # Returns the size of the Buffer
     %w( OFFSET SIZE ).each { |prop|
-      eval OpenCL.get_info("Mem", :size_t, prop)
+      eval get_info("Mem", :size_t, prop)
     }
 
     ##
@@ -62,28 +67,28 @@ module OpenCL
     # :method: reference_count()
     # Returns the Mem reference counter
     %w( MAP_COUNT REFERENCE_COUNT ).each { |prop|
-      eval OpenCL.get_info("Mem", :cl_uint, prop)
+      eval get_info("Mem", :cl_uint, prop)
     }
 
     ##
     # :method: uses_svn_pointer()
     # Returns true if Mem uses an SVM pointer
-    eval OpenCL.get_info("Mem", :cl_bool, "USES_SVM_POINTER")
+    eval get_info("Mem", :cl_bool, "USES_SVM_POINTER")
 
     ##
     # :method: type()
-    # Returns an OpenCL::Mem::Type corresponding to the Mem
-    eval OpenCL.get_info("Mem", :cl_mem_object_type, "TYPE")
+    # Returns a Mem::Type corresponding to the Mem
+    eval get_info("Mem", :cl_mem_object_type, "TYPE")
 
     ##
     # :method: flags()
-    # Returns an OpenCL::Mem::Flags corresponding to the flags used at Mem creation
-    eval OpenCL.get_info("Mem", :cl_mem_flags, "FLAGS")
+    # Returns a Mem::Flags corresponding to the flags used at Mem creation
+    eval get_info("Mem", :cl_mem_flags, "FLAGS")
 
     ##
     # :method: host_ptr()
     # Returns the host Pointer specified at Mem creation or the pointer + the ofsset if it is a sub-buffer. A null Pointer is returned otherwise.
-    eval OpenCL.get_info("Mem", :pointer, "HOST_PTR")
+    eval get_info("Mem", :pointer, "HOST_PTR")
 
     # Attaches a callback to memobj that will be called on the memobj destruction
     #
@@ -102,33 +107,33 @@ module OpenCL
 
     # Returns the texture_target argument specified in create_from_GL_texture for Mem
     def GL_texture_target
-      param_value = MemoryPointer::new( :cl_GLenum )
-      error = OpenCL.clGetGLTextureInfo( self, OpenCL::GL_TEXTURE_TARGET, param_value.size, param_value, nil )
-      OpenCL.error_check(error)
+      param_value = FFI::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
     end
 
     # Returns the miplevel argument specified in create_from_GL_texture for Mem
     def GL_mimap_level
-      param_value = MemoryPointer::new( :cl_GLint )
-      error = OpenCL.clGetGLTextureInfo( self, OpenCL::GL_MIPMAP_LEVEL, param_value.size, param_value, nil )
-      OpenCL.error_check(error)
+      param_value = FFI::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
     end
 
     # Returns the type of the GL object associated with Mem
     def GL_object_type
-      param_value = MemoryPointer::new( :cl_gl_object_type )
+      param_value = FFI::MemoryPointer::new( :cl_gl_object_type )
       error = OpenCL.clGetGLObjectInfo( self, param_value, nil )
-      OpenCL.error_check(error)
-      return OpenCL::GLObjectType::new(param_value.read_cl_gl_object_type)
+      error_check(error)
+      return GLObjectType::new(param_value.read_cl_gl_object_type)
     end
 
     # Returns the name of the GL object associated with Mem
     def GL_object_name
-      param_value = MemoryPointer::new( :cl_GLuint )
+      param_value = FFI::MemoryPointer::new( :cl_GLuint )
       error = OpenCL.clGetGLObjectInfo( self, nil, param_value )
-      OpenCL.error_check(error)
+      error_check(error)
       return param_value.read_cl_GLuint
     end
 

data/lib/opencl_ruby_ffi/Pipe.rb

@@ -22,6 +22,11 @@ module OpenCL
 
   # Maps the cl_mem OpenCL objects of type CL_MEM_OBJECT_PIPE
   class Pipe
+    include InnerInterface
+
+    class << self
+      include InnerGenerator
+    end
     
     ##
     # :method: packet_size
@@ -31,7 +36,7 @@ module OpenCL
     # :method: max_packets
     # Returns the max_packets of the Pipe
     %w( PACKET_SIZE MAX_PACKETS ).each { |prop|
-      eval OpenCL.get_info("Pipe", :cl_uint, prop)
+      eval get_info("Pipe", :cl_uint, prop)
     }
 
   end

data/lib/opencl_ruby_ffi/Platform.rb

@@ -71,6 +71,11 @@ module OpenCL
 
   # Maps the cl_platform_id object of OpenCL
   class Platform
+    include InnerInterface
+
+    class << self
+      include InnerGenerator
+    end
 
     ##
     # :method: profile()
@@ -88,32 +93,32 @@ module OpenCL
     # :mathod: vendor()
     # Returns a String identifying the Platform vendor
     %w(PROFILE VERSION NAME VENDOR).each { |prop|
-      eval OpenCL.get_info("Platform", :string, prop)
+      eval get_info("Platform", :string, prop)
     }
 
     # Returns an Array of string corresponding to the Platform extensions
     def extensions
       extensions_size = FFI::MemoryPointer::new( :size_t )
       error = OpenCL.clGetPlatformInfo( self, EXTENSIONS, 0, nil, extensions_size)
-      OpenCL.error_check(error)
+      error_check(error)
       ext = FFI::MemoryPointer::new( extensions_size.read_size_t )
       error = OpenCL.clGetPlatformInfo( self, EXTENSIONS, extensions_size.read_size_t, ext, nil)
-      OpenCL.error_check(error)
+      error_check(error)
       ext_string = ext.read_string
       return ext_string.split(" ")
     end
 
     # 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 = OpenCL::Device::Type::ALL)
+    def devices(type = Device::Type::ALL)
       ptr1 = FFI::MemoryPointer::new(:cl_uint , 1)
       error = OpenCL.clGetDeviceIDs(self, type, 0, nil, ptr1)
-      OpenCL.error_check(error)
+      error_check(error)
       ptr2 = FFI::MemoryPointer::new(:pointer, ptr1.read_uint)
       error = OpenCL.clGetDeviceIDs(self, type, ptr1.read_uint(), ptr2, nil)
-      OpenCL.error_check(error)
+      error_check(error)
       return ptr2.get_array_of_pointer(0, ptr1.read_uint()).collect { |device_ptr|
-        OpenCL::Device::new(device_ptr, false)
+        Device::new(device_ptr, false)
       }
     end
 
@@ -138,7 +143,7 @@ module OpenCL
     # * +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.
     def get_extension_function( name, return_type, param_types, options = {} )
-      OpenCL.error_check(OpenCL::INVALID_OPERATION) if self.version_number < 1.2
+      error_check(INVALID_OPERATION) if self.version_number < 1.2
       name_p = FFI::MemoryPointer.from_string(name)
       ptr = OpenCL.clGetExtensionFunctionAddressForPlatform( self, name_p )
       return nil if ptr.null?
@@ -158,7 +163,7 @@ module OpenCL
     # * +: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.
     def create_context_from_type(type, options = {}, &block)
-      props = [ OpenCL::Context::PLATFORM, self ]
+      props = [ Context::PLATFORM, self ]
       if options[:properties] then
         props = props +  options[:properties]
       else

data/lib/opencl_ruby_ffi/Program.rb

@@ -15,17 +15,7 @@ module OpenCL
   # * +: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
+    num_devices, devices_p = get_device_list( options )
     opt = ""
     opt = options[:options] if options[:options]
     options_p = FFI::MemoryPointer.from_string(opt)
@@ -50,26 +40,14 @@ module OpenCL
   # * +: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
+    num_devices, devices_p = get_device_list( options )
     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)
-    }
+    programs_p.write_array_of_pointer(programs)
     error = FFI::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)
@@ -91,18 +69,8 @@ module OpenCL
   # * +: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)
-      num_devices.times { |indx|
-        devices_p[indx].write_pointer(devices[indx])
-      }
-    end
+    @@callbacks.push( block ) if block
+    num_devices, devices_p = get_device_list( options )
     opt = ""
     opt = options[:options] if options[:options]
     options_p = FFI::MemoryPointer.from_string(opt)
@@ -220,6 +188,11 @@ module OpenCL
 
   # Maps the cl_program object of OpenCL
   class Program
+    include InnerInterface
+
+    class << self
+      include InnerGenerator
+    end
     alias_method :orig_method_missing, :method_missing
 
     # Intercepts a call to a missing method and tries to see if it is defined as a Kernel inside
@@ -229,7 +202,7 @@ module OpenCL
       k = nil
       begin
         k = self.create_kernel(m_string)
-      rescue OpenCL::Error
+      rescue Error
         k = nil
       end
       if k then
@@ -240,25 +213,25 @@ module OpenCL
     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")
+    eval get_info_array("Program", :size_t, "BINARY_SIZES")
 
     # Returns the number of Kernels defined in the Program
-    eval OpenCL.get_info("Program", :size_t, "NUM_KERNELS")
+    eval get_info("Program", :size_t, "NUM_KERNELS")
 
     # Returns an Array of String representing the Kernel names inside the Program
     def kernel_names
       kernel_names_size = FFI::MemoryPointer::new( :size_t )
       error = OpenCL.clGetProgramInfo( self, KERNEL_NAMES, 0, nil, kernel_names_size)
-      OpenCL.error_check(error)
+      error_check(error)
       k_names = FFI::MemoryPointer::new( kernel_names_size.read_size_t )
       error = OpenCL.clGetProgramInfo( self, KERNEL_NAMES, kernel_names_size.read_size_t, k_names, nil)
-      OpenCL.error_check(error)
+      error_check(error)
       k_names_string = k_names.read_string
       returns k_names_string.split(";")
     end
 
     # Returns the concatenated Program sources
-    eval OpenCL.get_info("Program", :string, "SOURCE")
+    eval get_info("Program", :string, "SOURCE")
 
     # Returns the total amount in byte used by the Program variables in the global address space for the Device(s) specified. Returns an Array of tuple [ Device, size ] (2.0 only)
     def build_global_variable_total_size(devs = nil)
@@ -267,7 +240,7 @@ module OpenCL
       ptr = FFI::MemoryPointer::new( :size_t )
       return devs.collect { |dev|
         error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_GLOBAL_VARIABLE_TOTAL_SIZE, ptr.size, ptr, nil)
-        OpenCL.error_check(error)
+        error_check(error)
         [dev, ptr.read_size_t]
       }
     end
@@ -279,8 +252,8 @@ module OpenCL
       ptr = FFI::MemoryPointer::new( :cl_build_status )
       return devs.collect { |dev|
         error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_STATUS, ptr.size, ptr, nil)
-        OpenCL.error_check(error)
-        [dev, OpenCL::BuildStatus::new(ptr.read_cl_build_status)]
+        error_check(error)
+        [dev, BuildStatus::new(ptr.read_cl_build_status)]
       }
     end
 
@@ -291,8 +264,8 @@ module OpenCL
       ptr = FFI::MemoryPointer::new( :cl_program_binary_type )
       return devs.collect { |dev|
         error = OpenCL.clGetProgramBuildInfo(self, dev, BINARY_TYPE, ptr.size, ptr, nil)
-        OpenCL.error_check(error)
-        [dev, OpenCL::Program::BinaryType::new(ptr.read_cl_program_binary_type)]
+        error_check(error)
+        [dev, BinaryType::new(ptr.read_cl_program_binary_type)]
       }
     end
 
@@ -303,10 +276,10 @@ module OpenCL
       return devs.collect { |dev|
         ptr1 = FFI::MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_OPTIONS, 0, nil, ptr1)
-        OpenCL.error_check(error)
+        error_check(error)
         ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
         error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_OPTIONS, ptr1.read_size_t, ptr2, nil)
-        OpenCL.error_check(error)
+        error_check(error)
         [dev, ptr2.read_string]
       }
     end
@@ -318,10 +291,10 @@ module OpenCL
       return devs.collect { |dev|
         ptr1 = FFI::MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_LOG, 0, nil, ptr1)
-        OpenCL.error_check(error)
+        error_check(error)
         ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
         error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_LOG, ptr1.read_size_t, ptr2, nil)
-        OpenCL.error_check(error)
+        error_check(error)
         [dev, ptr2.read_string]
       }
     end
@@ -337,7 +310,7 @@ module OpenCL
         bin_array[i].write_pointer(FFI::MemoryPointer::new(s))
       }
       error = OpenCL.clGetProgramInfo(self, BINARIES, total_size, bin_array, nil)
-      OpenCL.error_check(error)
+      error_check(error)
       bins = []
       devs = self.devices
       sizes.each_with_index { |s, i|
@@ -382,8 +355,8 @@ module OpenCL
     def context
       ptr = FFI::MemoryPointer::new( Context )
       error = OpenCL.clGetProgramInfo(self, CONTEXT, Context.size, ptr, nil)
-      OpenCL.error_check(error)
-      return OpenCL::Context::new( ptr.read_pointer )
+      error_check(error)
+      return Context::new( ptr.read_pointer )
     end
 
     ##
@@ -394,7 +367,7 @@ module OpenCL
     # :method: reference_count()
     # Returns the reference counter for this Program
     %w( NUM_DEVICES REFERENCE_COUNT ).each { |prop|
-      eval OpenCL.get_info("Program", :cl_uint, prop)
+      eval get_info("Program", :cl_uint, prop)
     }
 
     # Returns the Array of Device the Program is associated with
@@ -402,9 +375,9 @@ module OpenCL
       n = self.num_devices
       ptr2 = FFI::MemoryPointer::new( Device, n )
       error = OpenCL.clGetProgramInfo(self, DEVICES, Device.size*n, ptr2, nil)
-      OpenCL.error_check(error)
+      error_check(error)
       return ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
-        OpenCL::Device::new(device_ptr)
+        Device::new(device_ptr)
       }
     end
 

data/lib/opencl_ruby_ffi/Sampler.rb

@@ -61,34 +61,39 @@ module OpenCL
 
   # Maps the cl_smapler object of OpenCL
   class Sampler
+    include InnerInterface
+
+    class << self
+      include InnerGenerator
+    end
 
     # Returns the context associated with the Sampler
     def context
       ptr = FFI::MemoryPointer::new( Context )
       error = OpenCL.clGetSamplerInfo(self, CONTEXT, Context.size, ptr, nil)
-      OpenCL.error_check(error)
-      return OpenCL::Context::new( ptr.read_pointer )
+      error_check(error)
+      return Context::new( ptr.read_pointer )
     end
 
     ##
     # :method: reference_count()
     # returns the reference counter of the Sampler
-    eval OpenCL.get_info("Sampler", :cl_uint, "REFERENCE_COUNT")
+    eval get_info("Sampler", :cl_uint, "REFERENCE_COUNT")
 
     ##
     # :method: normalized_coords()
     # returns if the Sampler uses normalized coords
-    eval OpenCL.get_info("Sampler", :cl_bool, "NORMALIZED_COORDS")
+    eval get_info("Sampler", :cl_bool, "NORMALIZED_COORDS")
 
     ##
     # :method: addressing_mode()
     # returns an AddressingMode representing the addressing mode used by the Sampler
-    eval OpenCL.get_info("Sampler", :cl_addressing_mode, "ADDRESSING_MODE")
+    eval get_info("Sampler", :cl_addressing_mode, "ADDRESSING_MODE")
 
     ##
     # :method: filter_mode()
     # returns a FilterMode representing the filtering mode used by the Sampler
-    eval OpenCL.get_info("Sampler", :cl_filter_mode, "FILTER_MODE")
+    eval get_info("Sampler", :cl_filter_mode, "FILTER_MODE")
 
   end