opencl_ruby_ffi 1.2.2 → 1.3.0

data/lib/opencl_ruby_ffi/Mem.rb

@@ -22,16 +22,20 @@ module OpenCL
   # Maps the cl_mem object of OpenCL
   class Mem
     include InnerInterface
-
-    class << self
-      include InnerGenerator
-    end
+    extend InnerGenerator
 
     def inspect
       f = flags
       return "#<#{self.class.name}: #{size}#{ 0 != f.to_i ? " (#{f})" : ""}>"
     end
 
+    get_info("Mem", :cl_mem_object_type, "type")
+    get_info("Mem", :cl_mem_flags, "flags")
+    get_info("Mem", :size_t, "size")
+    get_info("Mem", :pointer, "host_ptr")
+    get_info("Mem", :cl_uint, "map_count")
+    get_info("Mem", :cl_uint, "reference_count")
+
     # Returns the Context associated to the Mem
     def context
       ptr = MemoryPointer::new( Context )
@@ -45,72 +49,6 @@ module OpenCL
       return self.context.platform
     end
 
-    # Returns the Buffer this Buffer was created from using create_sub_buffer
-    def associated_memobject
-      ptr = MemoryPointer::new( Mem )
-      error = OpenCL.clGetMemObjectInfo(self, ASSOCIATED_MEMOBJECT, Mem.size, ptr, nil)
-      error_check(error)
-      return nil if ptr.read_pointer.null?
-      return Mem::new( ptr.read_pointer )
-    end
-
-    ##
-    # :method: offset()
-    # Returns the offset used to create this Buffer using create_sub_buffer
-
-    ##
-    # :method: size()
-    # Returns the size of the Buffer
-    %w( OFFSET SIZE ).each { |prop|
-      eval get_info("Mem", :size_t, prop)
-    }
-
-    ##
-    # :method: map_count()
-    # Returns the number of times this Mem is mapped
-
-    ##
-    # :method: reference_count()
-    # Returns the Mem reference counter
-    %w( MAP_COUNT REFERENCE_COUNT ).each { |prop|
-      eval get_info("Mem", :cl_uint, prop)
-    }
-
-    ##
-    # :method: uses_svn_pointer()
-    # Returns true if Mem uses an SVM pointer
-    eval get_info("Mem", :cl_bool, "USES_SVM_POINTER")
-
-    ##
-    # :method: type()
-    # Returns a Mem::Type corresponding to the Mem
-    eval get_info("Mem", :cl_mem_object_type, "TYPE")
-
-    ##
-    # :method: 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 get_info("Mem", :pointer, "HOST_PTR")
-
-    # Attaches a callback to memobj that will be called on the memobj destruction
-    #
-    # ==== Attributes
-    #
-    # * +options+ - a hash containing named options
-    # * +block+ - if provided, a callback invoked when memobj is released. Signature of the callback is { |Mem, Pointer to user_data| ... }
-    #
-    # ==== Options
-    #
-    # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
-    def set_destructor_callback( options = {}, &proc )
-      OpenCL.set_mem_object_destructor_callback( self, options, &proc )
-      return self
-    end
-
     # Returns the texture_target argument specified in create_from_GL_texture for Mem
     def gl_texture_target
       param_value = MemoryPointer::new( :cl_GLenum )
@@ -147,6 +85,47 @@ module OpenCL
     end
     alias :GL_object_name :gl_object_name
 
+    module OpenCL11
+      extend InnerGenerator
+
+      get_info("Mem", :size_t, "offset")
+
+      # Returns the Buffer this Buffer was created from using create_sub_buffer
+      def associated_memobject
+        ptr = MemoryPointer::new( Mem )
+        error = OpenCL.clGetMemObjectInfo(self, ASSOCIATED_MEMOBJECT, Mem.size, ptr, nil)
+        error_check(error)
+        return nil if ptr.read_pointer.null?
+        return Mem::new( ptr.read_pointer )
+      end
+
+      # Attaches a callback to memobj that will be called on the memobj destruction
+      #
+      # ==== Attributes
+      #
+      # * +options+ - a hash containing named options
+      # * +block+ - if provided, a callback invoked when memobj is released. Signature of the callback is { |Mem, Pointer to user_data| ... }
+      #
+      # ==== Options
+      #
+      # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
+      def set_destructor_callback( options = {}, &proc )
+        OpenCL.set_mem_object_destructor_callback( self, options, &proc )
+        return self
+      end
+
+    end
+
+    module OpenCL20
+      extend InnerGenerator
+
+      get_info("Mem", :cl_bool, "uses_svm_pointer")
+
+    end
+
+    register_extension( :v11,  OpenCL11, "platform.version_number >= 1.1" )
+    register_extension( :v20,  OpenCL20, "platform.version_number >= 2.0" )
+
   end
 
 end

data/lib/opencl_ruby_ffi/Pipe.rb

@@ -24,26 +24,15 @@ module OpenCL
   # Maps the cl_mem OpenCL objects of type CL_MEM_OBJECT_PIPE
   class Pipe #< Mem
     include InnerInterface
-
-    class << self
-      include InnerGenerator
-    end
+    extend InnerGenerator
 
     def inspect
       f = flags
       return "#<#{self.class.inspect}: #{packet_size}x#{max_packets}#{ 0 != f.to_i ? " (#{f})" : ""}>"
     end
 
-    ##
-    # :method: packet_size
-    # Returns the packet_size of the Pipe
-
-    ##
-    # :method: max_packets
-    # Returns the max_packets of the Pipe
-    %w( PACKET_SIZE MAX_PACKETS ).each { |prop|
-      eval get_info("Pipe", :cl_uint, prop)
-    }
+    get_info("Pipe", :cl_uint, "packet_size")
+    get_info("Pipe", :cl_uint, "max_packets")
 
   end
 

data/lib/opencl_ruby_ffi/Platform.rb

@@ -35,6 +35,15 @@ module OpenCL
     return Function::new(return_type, param_types, ptr, options)
   end
 
+  def self.attach_extension_function( name, return_type, param_types, options = {} )
+    f = get_extension_function( name, return_type, param_types, options )
+    if not f then
+      warn "Warning: could not find extension function #{name}!"
+      return nil
+    end
+    f.attach(OpenCL, name)
+  end
+
   # Returns a Function corresponding to an extension function for the Platform
   #
   # ==== Attributes
@@ -73,42 +82,17 @@ module OpenCL
   # Maps the cl_platform_id object of OpenCL
   class Platform
     include InnerInterface
-
-    class << self
-      include InnerGenerator
-    end
+    extend InnerGenerator
 
     def inspect
       return "#<#{self.class.name}: #{self.name}>"
     end
 
-    ##
-    # :method: icd_suffix_khr()
-    # Returns a String containing the function name suffix used to identify extension functions to be directed to this platform by the ICD Loader
-
-    ##
-    # :method: profile()
-    # Returns a String containing the profile name supported by the Platform
-
-    ##
-    # :method: version()
-    # Returns a String containing the version number
-
-    ##
-    # :method: name()
-    # Returns a String containing the Platform name
-
-    ##
-    # :method: vendor()
-    # Returns a String identifying the Platform vendor
-    %w(PROFILE VERSION NAME VENDOR ICD_SUFFIX_KHR).each { |prop|
-      eval get_info("Platform", :string, prop)
-    }
-
-    ##
-    # :method: host_timer_resolution()
-    # returns the host timer resulution in nanoseconds
-    eval get_info("Platform", :cl_ulong, "HOST_TIMER_RESOLUTION")
+    get_info("Platform", :string, "profile")
+    get_info("Platform", :string, "version")
+    get_info("Platform", :string, "name")
+    alias to_s name
+    get_info("Platform", :string, "vendor")
 
     # Returns an Array of string corresponding to the Platform extensions
     def extensions
@@ -143,23 +127,6 @@ module OpenCL
       return n.first.first.to_f
     end
 
-    # Unloads the Platform compiler
-    def unload_compiler
-      return OpenCL.unload_platform_compiler(self)
-    end
-
-    # 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 Function::new. See FFI doc for details.
-    def get_extension_function( 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
     #
     # ==== Attributes
@@ -184,6 +151,37 @@ module OpenCL
       OpenCL.create_context_from_type(type, opts, &block)
     end
 
+    module OpenCL12
+
+      # 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 Function::new. See FFI doc for details.
+      def get_extension_function( name, return_type, param_types, options = {} )
+        return OpenCL.get_extension_function_for_platform( self, name, return_type, param_types, options )
+      end
+
+      # Unloads the Platform compiler
+      def unload_compiler
+        return OpenCL.unload_platform_compiler(self)
+      end
+
+    end
+
+    module OpenCL21
+      extend InnerGenerator
+
+      get_info("Platform", :cl_ulong, "host_timer_resolution")
+
+    end
+
+    register_extension( :v12, OpenCL12, "version_number >= 1.2" )
+    register_extension( :v21, OpenCL21, "version_number >= 2.1" )
+
   end
 
 end

data/lib/opencl_ruby_ffi/Program.rb

@@ -179,7 +179,7 @@ module OpenCL
     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)
+      c_strs_length[i].write_size_t(p.size == 0 ? 0 : p.size - 1) # minus the null character
     }
     error = MemoryPointer::new( :cl_int )
     program_ptr = clCreateProgramWithSource(context, c_strs_p.size, c_strs, c_strs_length, error)
@@ -207,10 +207,7 @@ module OpenCL
   # Maps the cl_program object of OpenCL
   class Program
     include InnerInterface
-
-    class << self
-      include InnerGenerator
-    end
+    extend InnerGenerator
 
     def inspect
       success = false
@@ -239,41 +236,50 @@ module OpenCL
       end
     end
 
-    # Returns an Array containing the sizes of the binary inside the Program for each device
-    eval get_info_array("Program", :size_t, "BINARY_SIZES")
+    # Returns the Context the Program is associated to
+    def context
+      ptr = MemoryPointer::new( Context )
+      error = OpenCL.clGetProgramInfo(self, CONTEXT, Context.size, ptr, nil)
+      error_check(error)
+      return Context::new( ptr.read_pointer )
+    end
 
-    # Returns the number of Kernels defined in the Program
-    eval get_info("Program", :size_t, "NUM_KERNELS")
+    get_info("Program", :cl_uint, "num_devices")
+    get_info("Program", :cl_uint, "reference_count")
 
-    # Returns an Array of String representing the Kernel names inside the Program
-    def kernel_names
-      if context.platform.version_number < 1.2 then
-        return kernels.collect(&:name)
-      else
-        kernel_names_size = MemoryPointer::new( :size_t )
-        error = OpenCL.clGetProgramInfo( self, KERNEL_NAMES, 0, nil, kernel_names_size)
-        error_check(error)
-        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
-        return k_names_string.split(";")
-      end
+    # Returns the Array of Device the Program is associated with
+    def devices
+      n = self.num_devices
+      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|
+        Device::new(device_ptr)
+      }
     end
 
-    # Returns the concatenated Program sources
-    eval get_info("Program", :string, "SOURCE")
+    get_info("Program", :string, "source")
+    get_info_array("Program", :size_t, "binary_sizes")
 
-    # 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)
-      devs = self.devices if not devs
-      devs = [devs].flatten
-      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)
-        [dev, ptr.read_size_t]
+    # 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 = MemoryPointer::new( :pointer, sizes.length )
+      total_size = 0
+      pointers = []
+      sizes.each_with_index { |s, i|
+        total_size += s
+        pointers[i] = MemoryPointer::new(s)
+        bin_array[i].write_pointer(pointers[i])
       }
+      error = OpenCL.clGetProgramInfo(self, BINARIES, total_size, bin_array, nil)
+      error_check(error)
+      bins = []
+      devs = self.devices
+      sizes.each_with_index { |s, i|
+        bins.push [devs[i], pointers[i].read_bytes(s)]
+      }
+      return bins
     end
 
     # 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 ]
@@ -288,18 +294,6 @@ module OpenCL
       }
     end
 
-    # 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 = MemoryPointer::new( :cl_program_binary_type )
-      return devs.collect { |dev|
-        error = OpenCL.clGetProgramBuildInfo(self, dev, BINARY_TYPE, ptr.size, ptr, nil)
-        error_check(error)
-        [dev, BinaryType::new(ptr.read_cl_program_binary_type)]
-      }
-    end
-
     # 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
@@ -330,39 +324,6 @@ module OpenCL
       }
     end
 
-    # 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 = MemoryPointer::new( :pointer, sizes.length )
-      sizes.length
-      total_size = 0
-      sizes.each_with_index { |s, i|
-        total_size += s
-        bin_array[i].write_pointer(MemoryPointer::new(s))
-      }
-      error = OpenCL.clGetProgramInfo(self, BINARIES, total_size, bin_array, nil)
-      error_check(error)
-      bins = []
-      devs = self.devices
-      sizes.each_with_index { |s, i|
-        bins.push [devs, bin_array[i].read_pointer.read_bytes(s)]
-      }
-      return bins
-    end
-
-    # Return the intermediate level representation of the program if any, nil otherwise
-    def il
-      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 = MemoryPointer::new( length )
-      error = OpenCL.clGetProgramInfo(self, IL, length, il_p, nil)
-      error_check(error)
-      return il_p.read_bytes(length)
-    end
-
     # Builds (compile and link) the Program created from sources or binary
     #
     # ==== Attributes
@@ -378,63 +339,109 @@ 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, 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)
+    # Returns the Kernel corresponding the the specified name in the Program
+    def create_kernel( name )
+      return OpenCL.create_kernel( self, name )
     end
 
-    # Returns the Context the Program is associated to
-    def context
-      ptr = MemoryPointer::new( Context )
-      error = OpenCL.clGetProgramInfo(self, CONTEXT, Context.size, ptr, nil)
-      error_check(error)
-      return Context::new( ptr.read_pointer )
+    # Returns an Array of Kernel corresponding to the kernels defined inside the Program
+    def kernels
+      return OpenCL.create_kernels_in_program( self )
+    end
+
+    def kernel_names
+      return kernels.collect(&:name)
     end
 
-    ##
-    # :method: num_devices()
-    # Returns the number of device this Program is associated with
+    module OpenCL12
+      extend InnerGenerator
+
+      get_info("Program", :size_t, "num_kernels")
+
+      # Returns an Array of String representing the Kernel names inside the Program
+      def kernel_names
+        if context.platform.version_number < 1.2 then
+          return kernels.collect(&:name)
+        else
+          kernel_names_size = MemoryPointer::new( :size_t )
+          error = OpenCL.clGetProgramInfo( self, KERNEL_NAMES, 0, nil, kernel_names_size)
+          error_check(error)
+          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
+          return k_names_string.split(";")
+        end
+      end
 
-    ##
-    # :method: reference_count()
-    # Returns the reference counter for this Program
-    %w( NUM_DEVICES REFERENCE_COUNT ).each { |prop|
-      eval get_info("Program", :cl_uint, prop)
-    }
+      # 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 = MemoryPointer::new( :cl_program_binary_type )
+        return devs.collect { |dev|
+          error = OpenCL.clGetProgramBuildInfo(self, dev, BINARY_TYPE, ptr.size, ptr, nil)
+          error_check(error)
+          [dev, BinaryType::new(ptr.read_cl_program_binary_type)]
+        }
+      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, 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 Array of Device the Program is associated with
-    def devices
-      n = self.num_devices
-      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|
-        Device::new(device_ptr)
-      }
     end
 
-    # Returns the Kernel corresponding the the specified name in the Program
-    def create_kernel( name )
-      return OpenCL.create_kernel( self, name )
+    module OpenCL20
+
+      # 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)
+        devs = self.devices if not devs
+        devs = [devs].flatten
+        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)
+          [dev, ptr.read_size_t]
+        }
+      end
+
     end
 
-    # Returns an Array of Kernel corresponding to the kernels defined inside the Program
-    def kernels
-      return OpenCL.create_kernels_in_program( self )
+    module OpenCL21
+
+      # Return the intermediate level representation of the program if any, nil otherwise
+      def il
+        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 = MemoryPointer::new( length )
+        error = OpenCL.clGetProgramInfo(self, IL, length, il_p, nil)
+        error_check(error)
+        return il_p.read_bytes(length)
+      end
+
     end
 
+    register_extension( :v12, OpenCL12, "context.platform.version_number >= 1.2" )
+    register_extension( :v20, OpenCL20, "context.platform.version_number >= 2.0" )
+    register_extension( :v21, OpenCL21, "context.platform.version_number >= 2.1" )
+
   end
 
 end