opencl_ruby_ffi 0.1

data/lib/opencl_ruby_ffi/Context.rb

@@ -0,0 +1,326 @@
+module OpenCL
+
+  # Creates an Context using the specified devices
+  #
+  # ==== Attributes
+  #
+  # * +devices+ - array of Device or a single Device
+  # * +options+ - a hash containing named options
+  # * +block+ - if provided, a callback invoked when error arise in the context. Signature of the callback is { |FFI::Pointer to null terminated c string, FFI::Pointer to binary data, :size_t number of bytes of binary data, FFI::Pointer to user_data| ... }
+  #
+  # ==== Options
+  # 
+  # * +:properties+ - a list of :cl_context_properties
+  # * +: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 self.create_context(devices, options = {}, &block)
+    @@callbacks.push( block ) if block
+    pointer = FFI::MemoryPointer.new( Device, devices.size)
+    devices.size.times { |indx|
+      pointer.put_pointer(indx, devices[indx])
+    }
+    properties = OpenCL.get_context_properties( options )
+    user_data = options[:user_data]
+    error = FFI::MemoryPointer.new( :cl_int )
+    ptr = OpenCL.clCreateContext(properties, devices.size, pointer, block, user_data, error)
+    OpenCL.error_check(error.read_cl_int)
+    return OpenCL::Context::new(ptr, false)
+  end
+
+  # Creates an Context using devices of the selected type
+  #
+  # ==== Attributes
+  #
+  # * +type+ - array of Device or a single Device
+  # * +options+ - a hash containing named options
+  # * +block+ - if provided, a callback invoked when error arise in the context. Signature of the callback is { |FFI::Pointer to null terminated c string, FFI::Pointer to binary data, :size_t number of bytes of binary data, FFI::Pointer to user_data| ... }
+  #
+  # ==== Options
+  # 
+  # * +:properties+ - a list of :cl_context_properties
+  # * +: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 self.create_context_from_type(type, options = {}, &block)
+    @@callbacks.push( block ) if block
+    properties = OpenCL.get_context_properties( options )
+    user_data = options[:user_data]
+    error = FFI::MemoryPointer.new( :cl_int )
+    ptr = OpenCL.clCreateContextFromType(properties, type, block, user_data, error)
+    OpenCL.error_check(error.read_cl_int)
+    return OpenCL::Context::new(ptr, false)
+  end
+
+  #Maps the cl_context object of OpenCL
+  class Context
+
+    ##
+    # :method: reference_count
+    # Returns the reference count of the Context
+    %w( REFERENCE_COUNT ).each { |prop|
+      eval OpenCL.get_info("Context", :cl_uint, prop)
+    }
+
+    ##
+    # :method: properties
+    # the Array of :cl_context_properties used to create the Context
+    eval OpenCL.get_info_array("Context", :cl_context_properties, "PROPERTIES")
+
+    # Returns the platform associated to the Context
+    def platform
+      self.devices.first.platform
+    end
+
+    # Returns the number of devices associated to the Context
+    def num_devices
+      d_n = 0
+      ptr = FFI::MemoryPointer.new( :size_t )
+      error = OpenCL.clGetContextInfo(self, Context::DEVICES, 0, nil, ptr)
+      OpenCL.error_check(error)
+      d_n = ptr.read_size_t / Platform.size
+#      else
+#        ptr = FFI::MemoryPointer.new( :cl_uint )
+#        error = OpenCL.clGetContextInfo(self, Context::NUM_DEVICES, ptr.size, ptr, nil)
+#        OpenCL.error_check(error)
+#        d_n = ptr.read_cl_uint
+#      end
+      return d_n
+    end
+
+    # Returns an Array of Device associated to the Context
+    def devices
+      n = self.num_devices
+      ptr2 = FFI::MemoryPointer.new( Device, n )
+      error = OpenCL.clGetContextInfo(self, Context::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)
+      }
+    end
+
+    # Returns an Array of ImageFormat that are supported for a given image type in the Context
+    #
+    # ==== Attributes
+    # * +image_type+ - a :cl_mem_object_type specifying the type of Image being queried
+    # * +options+ - a hash containing named options
+    #
+    # ==== Options
+    # 
+    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
+    def supported_image_formats( image_type, options = {} )
+      flags = OpenCL.get_flags( options )
+      num_image_formats = FFI::MemoryPointer.new( :cl_uint )
+      error = OpenCL.clGetSupportedImageFormats( self, flags, image_type, 0, nil, num_image_formats )
+      OpenCL.error_check(error)
+      num_entries = num_image_formats.read_cl_uint
+      image_formats = FFI::MemoryPointer.new( ImageFormat, num_entries )
+      error = OpenCL.clGetSupportedImageFormats( self, flags, image_type, num_entries, image_formats, nil )
+      OpenCL.error_check(error)
+      return num_entries.times.collect { |i|
+        OpenCL::ImageFormat::from_pointer( image_formats + i * ImageFormat.size )
+      }
+    end
+
+    # Creates a CommandQueue in Context targeting the specified Device
+    #
+    # ==== Attributes
+    #
+    # * +device+ - the Device targetted by the CommandQueue being created
+    # * +options+ - a hash containing named options
+    #
+    # ==== Options
+    # 
+    # * +:properties+ - a single or an Array of :cl_command_queue_properties
+    def create_command_queue( device, options = {} )
+      return OpenCL.create_command_queue( self, device, options )
+    end
+
+    # Creates a Buffer in the Context
+    #
+    # ==== Attributes
+    #
+    # * +size+ - size of the Buffer to be created
+    # * +options+ - a hash containing named options
+    #
+    # ==== Options
+    # 
+    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
+    # * +:host_ptr+ - if provided, the Pointer (or convertible to Pointer using to_ptr) to the memory area to use
+    def create_buffer( size, options = {} )
+      return OpenCL.create_buffer( self, size, options )
+    end
+
+    # Creates a Buffer in the Context from an opengl buffer
+    #
+    # ==== Attributes
+    #
+    # * +bufobj+ - opengl buffer object
+    # * +options+ - a hash containing named options
+    #
+    # ==== Options
+    #
+    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image
+    def create_from_GL_buffer( bufobj, options = {} )
+      return OpenCL.create_from_GL_buffer( self, bufobj, options )
+    end
+
+    # Creates an Image in the Context from an OpenGL render buffer
+    #
+    # ==== Attributes
+    #
+    # * +renderbuf+ - opengl render buffer
+    # * +options+ - a hash containing named options
+    #
+    # ==== Options
+    #
+    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image
+    def create_from_GL_render_buffer( renderbuffer, options = {} )
+      return OpenCL.create_from_GL_render_buffer( self, renderbuffer, options )
+    end
+
+    # Creates an Image in the Context from an OpenGL texture
+    #
+    # ==== Attributes
+    #
+    # * +texture_target+ - a :GLenum defining the image type of texture
+    # * +texture+ - a :GLuint specifying the name of the texture
+    # * +options+ - a hash containing named options
+    #
+    # ==== Options
+    #
+    # * +:miplevel+ - a :GLint specifying the mipmap level to be used (default 0)
+    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image
+    def create_from_GL_texture( texture_target, texture, options = {} )
+      return OpenCL.create_from_GL_texture( self, texture_target, texture, options )
+    end
+
+    # Creates an Image in the Context from an OpenGL 2D texture
+    #
+    # ==== Attributes
+    #
+    # * +texture_target+ - a :GLenum defining the image type of texture
+    # * +texture+ - a :GLuint specifying the name of the texture
+    # * +options+ - a hash containing named options
+    #
+    # ==== Options
+    #
+    # * +:miplevel+ - a :GLint specifying the mipmap level to be used (default 0)
+    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image
+    def create_from_GL_texture_2D( texture_target, texture, options = {} )
+      return OpenCL.create_from_GL_texture_2D( self, texture_target, texture, options = {} )
+    end
+
+    # Creates an Image in the Context from an OpenGL 3D texture
+    #
+    # ==== Attributes
+    #
+    # * +texture_target+ - a :GLenum defining the image type of texture
+    # * +texture+ - a :GLuint specifying the name of the texture
+    # * +options+ - a hash containing named options
+    #
+    # ==== Options
+    #
+    # * +:miplevel+ - a :GLint specifying the mipmap level to be used (default 0)
+    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image
+    def create_from_GL_texture_3D( texture_target, texture, options = {} )
+      return OpenCL.create_from_GL_texture_3D( self, texture_target, texture, options )
+    end
+
+    # Creates an Image in the Context
+    #
+    # ==== Attributes
+    #
+    # * +format+ - an ImageFormat
+    # * +options+ - an ImageDesc
+    #
+    # ==== Options
+    # 
+    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
+    # * +:host_ptr+ - if provided, the Pointer (or convertible to Pointer using to_ptr) to the memory area to use
+    def create_image( format, desc, options = {} )
+      return OpenCL.create_image( self, format, desc, options )
+    end
+
+    # Creates a 1D Image in the Context
+    #
+    # ==== Attributes
+    #
+    # * +format+ - an ImageFormat
+    # * +width+ - width of the image
+    #
+    # ==== Options
+    # 
+    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
+    # * +:host_ptr+ - if provided, the Pointer (or convertible to Pointer using to_ptr) to the memory area to use
+    def create_image_1D( format, width, options = {} )
+      return OpenCL.create_image_1D( self, format, width, options )
+    end
+
+    # Creates a 2D Image in the Context
+    #
+    # ==== Attributes
+    #
+    # * +format+ - an ImageFormat
+    # * +width+ - width of the image
+    #
+    # ==== Options
+    # 
+    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
+    # * +:host_ptr+ - if provided, the Pointer (or convertible to Pointer using to_ptr) to the memory area to use
+    # * +:row_pitch+ - if provided the row_pitch of data in host_ptr
+    def create_image_2D( format, width, height, options = {} )
+      return OpenCL.create_image_2D( self, format, width, height, options )
+    end
+
+    # Creates a 3D Image in the Context
+    #
+    # ==== Attributes
+    #
+    # * +format+ - an ImageFormat
+    # * +width+ - width of the image
+    #
+    # ==== Options
+    # 
+    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
+    # * +:host_ptr+ - if provided, the Pointer (or convertible to Pointer using to_ptr) to the memory area to use
+    # * +:row_pitch+ - if provided the row_pitch of data in host_ptr
+    # * +:slice_pitch+ - if provided the slice_pitch of data in host_ptr
+    def create_image_3D( format, width, height, depth, options = {} )
+      return OpenCL.create_image_3D( self, format, width, height, depth, options )
+    end
+
+    # Creates an Event in the Context from a GL sync
+    #
+    # ==== Attributes
+    #
+    # * +sync+ - a :GLsync representing the name of the sync object
+    def create_event_from_GL_sync_KHR( sync )
+      return OpenCL.create_event_from_GL_sync_KHR( self, sync )
+    end
+
+
+    # Creates a user Event in the Context
+    def create_user_event
+      return OpenCL.create_user_event(self)
+    end
+
+    # Creates a Program from sources in the Context
+    #
+    # ==== Attributes
+    #
+    # * +strings+ - a single or an Array of String repesenting the program source code
+    def create_program_with_source( strings )
+      return OpenCL.create_program_with_source(self, strings)
+    end
+
+    # Creates a Sampler in the Context
+    #
+    # ==== Attributes
+    #
+    # * +normalized_coords+ - a :cl_bool specifying if the image coordinates are normalized
+    # * +addressing_mode+ - a :cl_addressing_mode specifying how out-of-range image coordinates are handled when reading from an image
+    # * +filter_mode+ - a :cl_filter_mode specifying the type of filter that must be applied when reading an image
+    def create_sampler( normalized_coords, addressing_mode, filter_mode )
+      return OpenCL.create_sampler( self, normalized_coords, addressing_mode, filter_mode )
+    end
+  end
+
+end
+

data/lib/opencl_ruby_ffi/Device.rb

@@ -0,0 +1,188 @@
+module OpenCL
+
+  # Splits a Device in serveral sub-devices
+  #
+  # ==== Attributes
+  # 
+  # * +in_device+ - the Device to be partitioned
+  # * +properties+ - an Array of cl_device_partition_property
+  #
+  # ==== Returns
+  #
+  # an Array of Device
+  def self.create_sub_devices( in_device, properties = [OpenCL::Device::PARTITION_BY_AFFINITY_DOMAIN, OpenCL::Device::AFFINITY_DOMAIN_NEXT_PARTITIONABLE] )
+    OpenCL.error_check(OpenCL::INVALID_OPERATION) if in_device.platform.version_number < 1.2
+    props = FFI::MemoryPointer::new( :cl_device_partition_property, properties.length + 1 )
+    properties.each_with_index { |e,i|
+      props[i].write_cl_device_partition_property(e)
+    }
+    props[properties.length].write_cl_device_partition_property(0)
+    device_number_ptr = FFI::MemoryPointer::new( :cl_uint )
+    error = OpenCL.clCreateSubDevice( in_device, props, 0, nil, device_number_ptr )
+    OpenCL.error_check(error)
+    device_number = device_number_ptr.read_cl_uint
+    devices_ptr = FFI::MemoryPointer::new( OpenCL::Device, device_number )
+    error = OpenCL.clCreateSubDevice( in_device, props, device_number, devices_ptr, nil )
+    OpenCL.error_check(error)
+    devices_ptr.get_array_of_pointer(0, device_number).collect { |device_ptr|
+        OpenCL::Device.new(device_ptr, false)
+    }
+  end
+
+  # Maps the cl_device_id object of OpenCL
+  class Device
+
+    # :stopdoc:
+    DRIVER_VERSION = 0x102D
+    # :startdoc:
+
+    %w( BUILT_IN_KERNELS DRIVER_VERSION VERSION VENDOR PROFILE OPENCL_C_VERSION NAME EXTENSIONS ).each { |prop|
+      eval OpenCL.get_info("Device", :string, prop)
+    }
+
+    %w( MAX_MEM_ALLOC_SIZE MAX_CONSTANT_BUFFER_SIZE LOCAL_MEM_SIZE GLOBAL_MEM_CACHE_SIZE GLOBAL_MEM_SIZE ).each { |prop|
+      eval OpenCL.get_info("Device", :cl_ulong, prop)
+    }
+
+    %w( IMAGE_PITCH_ALIGNMENT IMAGE_BASE_ADDRESS_ALIGNMENT REFERENCE_COUNT PARTITION_MAX_SUB_DEVICES VENDOR_ID PREFERRED_VECTOR_WIDTH_HALF PREFERRED_VECTOR_WIDTH_CHAR PREFERRED_VECTOR_WIDTH_SHORT PREFERRED_VECTOR_WIDTH_INT PREFERRED_VECTOR_WIDTH_LONG PREFERRED_VECTOR_WIDTH_FLOAT PREFERRED_VECTOR_WIDTH_DOUBLE NATIVE_VECTOR_WIDTH_CHAR NATIVE_VECTOR_WIDTH_SHORT NATIVE_VECTOR_WIDTH_INT NATIVE_VECTOR_WIDTH_LONG NATIVE_VECTOR_WIDTH_FLOAT NATIVE_VECTOR_WIDTH_DOUBLE NATIVE_VECTOR_WIDTH_HALF MIN_DATA_TYPE_ALIGN_SIZE MEM_BASE_ADDR_ALIGN MAX_WRITE_IMAGE_ARGS MAX_WORK_ITEM_DIMENSIONS MAX_SAMPLERS MAX_READ_IMAGE_ARGS MAX_CONSTANT_ARGS MAX_COMPUTE_UNITS MAX_CLOCK_FREQUENCY ADDRESS_BITS GLOBAL_MEM_CACHELINE_SIZE ).each { |prop|
+      eval OpenCL.get_info("Device", :cl_uint, prop)
+    }
+
+    %w( PRINTF_BUFFER_SIZE IMAGE_MAX_BUFFER_SIZE IMAGE_MAX_ARRAY_SIZE PROFILING_TIMER_RESOLUTION MAX_WORK_GROUP_SIZE MAX_PARAMETER_SIZE IMAGE2D_MAX_WIDTH IMAGE2D_MAX_HEIGHT IMAGE3D_MAX_WIDTH IMAGE3D_MAX_HEIGHT IMAGE3D_MAX_DEPTH ).each { |prop|
+      eval OpenCL.get_info("Device", :size_t, prop)
+    }
+
+    %w( PREFERRED_INTEROP_USER_SYNC LINKER_AVAILABLE IMAGE_SUPPORT HOST_UNIFIED_MEMORY COMPILER_AVAILABLE AVAILABLE ENDIAN_LITTLE ERROR_CORRECTION_SUPPORT ).each { |prop|
+      eval OpenCL.get_info("Device", :cl_bool, prop)
+    }
+
+    %w( SINGLE_FP_CONFIG HALF_FP_CONFIG DOUBLE_FP_CONFIG ).each { |prop|
+      eval OpenCL.get_info("Device", :cl_device_fp_config, prop)
+    }
+
+    ##
+    # :method: execution_capabilities()
+    # Returns an ExecCpabilities representing the execution capabilities corresponding to the Device
+    eval OpenCL.get_info("Device", :cl_device_exec_capabilities, "EXECUTION_CAPABILITIES")
+
+    ##
+    # :method: global_mem_cache_type()
+    # Returns a MemCacheType representing the type of the global cache memory on the Device
+    eval OpenCL.get_info("Device", :cl_device_mem_cache_type, "GLOBAL_MEM_CACHE_TYPE")
+
+    ##
+    # :method: local_mem_type()
+    # Returns a LocalMemType rpresenting the type of the local memory on the Device
+    eval OpenCL.get_info("Device", :cl_device_local_mem_type, "LOCAL_MEM_TYPE")
+
+    ##
+    # :method: queue_properties()
+    # Returns a CommandQueue::Properties representing the properties supported by a CommandQueue targetting the Device
+    eval OpenCL.get_info("Device", :cl_command_queue_properties, "QUEUE_PROPERTIES")
+
+    ##
+    # :method: type()
+    # Returns a Device::Type representing the type of the Device
+    eval OpenCL.get_info("Device", :cl_device_type, "TYPE")
+
+    ##
+    # :method: partition_affinity_domain()
+    # Returns an AffinityDomain representing the list of supported affinity domains for partitioning the Device using OpenCL::Device::PARTITION_BY_AFFINITY_DOMAIN
+    eval OpenCL.get_info("Device", :cl_device_affinity_domain, "PARTITION_AFFINITY_DOMAIN")
+
+    ##
+    # :method: max_work_item_sizes()
+    # Maximum number of work-items that can be specified in each dimension of the work-group to clEnqueueNDRangeKernel for the Device
+    eval OpenCL.get_info_array("Device", :size_t, "MAX_WORK_ITEM_SIZES")
+
+    ##
+    # :method: partition_properties()
+    # Returns the list of partition types supported by the Device
+    eval OpenCL.get_info_array("Device", :cl_device_partition_property, "PARTITION_PROPERTIES")
+
+    # Return an Array of partition properties names representing the partition type supported by the device
+    def partition_properties_names
+      prop_names = []
+      props = self.partition_properties
+      %w( PARTITION_EQUALLY PARTITION_BY_COUNTS PARTITION_BY_AFFINITY_DOMAIN ).each { |prop|
+        prop_names.push(prop) if props.include?(OpenCL::Device.const_get(prop))
+      }
+    end
+
+    ##
+    # :method: partition_type()
+    # Returns a list of :cl_device_partition_property used to create the Device
+    eval OpenCL.get_info_array("Device", :cl_device_partition_property, "PARTITION_TYPE")
+
+    # Returns the platform the Device belongs to
+    def platform
+      ptr = FFI::MemoryPointer.new( OpenCL::Platform )
+      error = OpenCL.clGetDeviceInfo(self, Device::PLATFORM, OpenCL::Platform.size, ptr, nil)
+      OpenCL.error_check(error)
+      return OpenCL::Platform.new(ptr.read_pointer)
+    end
+
+    # Returns the parent Device if it exists
+    def parent_device
+      ptr = FFI::MemoryPointer.new( OpenCL::Device )
+      error = OpenCL.clGetDeviceInfo(self, Device::PARENT_DEVICE, OpenCL::Device.size, ptr, nil)
+      OpenCL.error_check(error)
+      return nil if ptr.null?
+      return OpenCL::Device.new(ptr.read_pointer)
+    end
+
+    # Partitions the Device in serveral sub-devices
+    #
+    # ==== Attributes
+    # 
+    # * +properties+ - an Array of :cl_device_partition_property
+    #
+    # ==== Returns
+    #
+    # an Array of Device
+    def create_sub_devices( properties )
+      return OpenCL.create_sub_devices( self, properties )
+    end
+
+    # Partitions the Device in serveral sub-devices by affinity domain
+    #
+    # ==== Attributes
+    # 
+    # * +affinity_domain+ - the :cl_device_partition_property specifying the target affinity domain
+    #
+    # ==== Returns
+    #
+    # an Array of Device
+    def partition_by_affinity_domain( affinity_domain = OpenCL::Device::AFFINITY_DOMAIN_NEXT_PARTITIONABLE )
+      return OpenCL.create_sub_devices( self,  [ OpenCL::Device::PARTITION_BY_AFFINITY_DOMAIN, affinity_domain ] )
+    end
+
+    # Partitions the Device in serveral sub-devices containing compute_unit_number compute units
+    #
+    # ==== Attributes
+    # 
+    # * +compute_unit_number+ - the number of compute units in each sub-device
+    #
+    # ==== Returns
+    #
+    # an Array of Device
+    def partition_equally( compute_unit_number = 1 )
+      return OpenCL.create_sub_devices( self,  [ OpenCL::Device::PARTITION_EQUALLY, compute_unit_number ] )
+    end
+
+    # Partitions the Device in serveral sub-devices each containing a specific number of compute units
+    #
+    # ==== Attributes
+    # 
+    # * +compute_unit_number_list+ - an Array of compute unit number
+    #
+    # ==== Returns
+    #
+    # an Array of Device
+    def partition_by_count( compute_unit_number_list = [1] )
+      return OpenCL.create_sub_devices( self,  [ OpenCL::Device::PARTITION_BY_COUNTS] + compute_unit_number_list + [ OpenCL::Device::PARTITION_BY_COUNTS_LIST_END ] )
+    end
+
+  end
+
+end