opencl_ruby_ffi 1.3.6 → 1.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4325bde909438bcb5c293f84f9f3f7da0932abf023bc87df395110af66fde34
-  data.tar.gz: 745fc7ce91505ae771d56fbf386a0d650dbd5866c0cf2bbde4b799af29f5d655
+  metadata.gz: abb565a3d9a1e180eebf1e28ab06d330a4ae2477522ba2b22c0211bf7c720bc4
+  data.tar.gz: 2e47f057d7cf5a79a3972f8a3ab1ac7291827020c607c465d357b58824683ec5
 SHA512:
-  metadata.gz: b88bd68ba1ab4a335e6342eb62a38b07709669a1c2ac32b572d5f46e13138002a33c7efe790c0f1342a9348b30711a2f0b165418abf404fc3bf4f05f9819cc67
-  data.tar.gz: 7dedd2f91608263c61c13a997a9949b240dd24c34fa2fd130466007c3ad571d86f81e00c98b64ec5b0b384c11e7ab22d51a444c255deee83b9114b7752def527
+  metadata.gz: d144d10d5744d13cf235a2f0ff4b9fa2bb1df7d47fc4c9b4799c233d1f9e2dc71f30f66c84cdf4a55db197cb6a4175b654845ac6be97c03ed57ea4b931508a10
+  data.tar.gz: 29561be75358ae7ae658a365f602930ff62a4bf5854ca1a0f0547ff5b7c4703ca01bd19fc036b15b3a503a0b3990eaa482d0c95c66b0be1b388316fa09e3348b

data/lib/opencl_ruby_ffi/CommandQueue.rb

@@ -1070,6 +1070,12 @@ module OpenCL
       return "#<#{self.class.name}: -> #{device.inspect}#{ 0 != p.to_i ? " (#{p})" : ""}>"
     end
 
+    # Returns the Platform associated with the CommandQueue
+    def platform
+      return @_platform if @_platform
+      @_platform = self.context.platform
+    end
+
     # Returns the Context associated to the CommandQueue
     def context
       ptr = MemoryPointer::new( Context )
@@ -1654,11 +1660,11 @@ module OpenCL
       # 
       # * +dst_ptr+ - the Pointer (or convertible to Pointer using to_ptr) or SVMPointer to be written to
       # * +src_ptr+ - the Pointer (or convertible to Pointer using to_ptr) or SVMPointer to be read from
-      # * +size+ - the size of data to copy
       # * +options+ - a hash containing named options
       #
       # ==== Options
       #
+      # * +:size+ - the size of data to copy
       # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
       # * +:blocking_copy+ - if provided indicates if the command blocks until the copy finishes
       # * +:blocking+ - if provided indicates if the command blocks until the copy finishes
@@ -1666,8 +1672,8 @@ module OpenCL
       # ==== Returns
       #
       # the Event associated with the command
-      def enqueue_svm_memcpy( dst_ptr, src_ptr, size, options = {})
-        return OpenCL.enqueue_svm_memcpy(self, dst_ptr, src_ptr, size, options)
+      def enqueue_svm_memcpy( dst_ptr, src_ptr, options = {})
+        return OpenCL.enqueue_svm_memcpy(self, dst_ptr, src_ptr, options)
       end
 
       # Enqueues a command that frees SVMPointers (or Pointers using a callback) using the CommandQueue
@@ -1696,31 +1702,32 @@ module OpenCL
       #
       # * +svm_ptr+ - the SVMPointer to the area to fill
       # * +pattern+ - the Pointer (or convertible to Pointer using to_ptr) to the memory area where the pattern is stored
-      # * +size+ - the size of the area to fill
       #
       # ==== Options
       #
+      # * +:size+ - the size of the area to fill
       # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
       # * +:pattern_size+ - if provided indicates the size of the pattern, else the maximum pattern data is used
       #
       # ==== Returns
       #
       # the Event associated with the command
-      def enqueue_svm_memfill( svm_ptr, pattern, size, options = {})
-        return OpenCL.enqueue_svm_memfill(self, svm_ptr, pattern, size, options)
+      def enqueue_svm_memfill( svm_ptr, pattern, options = {})
+        return OpenCL.enqueue_svm_memfill(self, svm_ptr, pattern, options)
       end
+      alias enqueue_svm_mem_fill enqueue_svm_memfill
 
       # Enqueues a command to map an Image into host memory using the CommandQueue
       #
       # ==== Attributes
       # 
       # * +svm_ptr+ - the SVMPointer to the area to map
-      # * +size+ - the size of the region to map
       # * +map_flags+ - a single or an Array of :cl_map_flags flags
       # * +options+ - a hash containing named options
       #
       # ==== Options
       #
+      # * +:size+ - the size of the region to map
       # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
       # * +:blocking_map+ - if provided indicates if the command blocks until the region is mapped
       # * +:blocking+ - if provided indicates if the command blocks until the region is mapped
@@ -1728,8 +1735,8 @@ module OpenCL
       # ==== Returns
       #
       # the Event associated with the command
-      def enqueue_svm_map( svm_ptr, size, map_flags, options = {} )
-        return OpenCL.enqueue_svm_map( self, svm_ptr, size, map_flags, options )
+      def enqueue_svm_map( svm_ptr, map_flags, options = {} )
+        return OpenCL.enqueue_svm_map( self, svm_ptr, map_flags, options )
       end
     
       # Enqueues a command to unmap a previously mapped SVM memory area using the CommandQueue

data/lib/opencl_ruby_ffi/Context.rb

@@ -14,7 +14,9 @@ module OpenCL
   # * +:properties+ - a list of :cl_context_properties
   # * +:user_data+ - an 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
+    if block
+      @@callbacks[block] = options[:user_data]
+    end
     devs = [devices].flatten
     pointer = MemoryPointer::new( Device, devs.size)
     pointer.write_array_of_pointer(devs)
@@ -39,7 +41,9 @@ module OpenCL
   # * +:properties+ - a list of :cl_context_properties
   # * +:user_data+ - an 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
+    if block
+      @@callbacks[block] = options[:user_data]
+    end
     properties = get_context_properties( options )
     user_data = options[:user_data]
     error = MemoryPointer::new( :cl_int )
@@ -68,23 +72,26 @@ module OpenCL
 
     # Returns the number of devices associated to the Context
     def num_devices
+      return @_num_devices if @_num_devices
       d_n = 0
       ptr = MemoryPointer::new( :size_t )
       error = OpenCL.clGetContextInfo(self, DEVICES, 0, nil, ptr)
       error_check(error)
       d_n = ptr.read_size_t / Platform.size
-      return d_n
+      @_num_devices = d_n
     end
 
     # Returns an Array of Device associated to the Context
     def devices
+      return @_devices if @_devices
       n = self.num_devices
       ptr2 = MemoryPointer::new( Device, n )
       error = OpenCL.clGetContextInfo(self, DEVICES, Device.size*n, ptr2, nil)
       error_check(error)
-      return ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
+      @_devices = ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
         Device::new(device_ptr)
       }
+      return @_devices
     end
 
     ##
@@ -118,7 +125,8 @@ module OpenCL
 
     # Returns the platform associated to the Context
     def platform
-      self.devices.first.platform
+      return @_platform if @_platform
+      @_platform = self.devices.first.platform
     end
 
     # Returns an Array of ImageFormat that are supported for a given image type in the Context

data/lib/opencl_ruby_ffi/Device.rb

@@ -14,7 +14,7 @@ module OpenCL
   def self.create_sub_devices( in_device, properties )
     error_check(INVALID_OPERATION) if in_device.platform.version_number < 1.2
     props = MemoryPointer::new( :cl_device_partition_property, properties.length + 1 )
-    properties.each_with_index { |e,i|
+    properties.each_with_index { |e, i|
       props[i].write_cl_device_partition_property(e)
     }
     props[properties.length].write_cl_device_partition_property(0)
@@ -56,7 +56,7 @@ module OpenCL
       return "#<#{self.class.name}: #{name} (#{pointer.to_i})>"
     end
 
-    get_info("Device", :cl_uint, "address_bits")
+    get_info("Device", :cl_uint, "address_bits", true)
     get_info("Device", :cl_bool, "available")
     get_info("Device", :cl_bool, "compiler_available")
     get_info("Device", :cl_bool, "endian_little")
@@ -101,16 +101,17 @@ module OpenCL
     get_info("Device", :cl_uint, "max_write_image_args")
     get_info("Device", :cl_uint, "mem_base_addr_align")
     get_info("Device", :cl_uint, "min_data_type_align_size")
-    get_info("Device", :string,  "name")
+    get_info("Device", :string,  "name", true)
 
     alias to_s name
 
     # Returns the Platform the Device belongs to
     def platform
+      return @_platform if @_platform
       ptr = MemoryPointer::new( OpenCL::Platform )
       error = OpenCL.clGetDeviceInfo(self, PLATFORM, OpenCL::Platform.size, ptr, nil)
       error_check(error)
-      return OpenCL::Platform::new(ptr.read_pointer)
+      @_platform = OpenCL::Platform::new(ptr.read_pointer)
     end
 
     get_info("Device", :cl_uint, "preferred_vector_width_char")
@@ -119,14 +120,14 @@ module OpenCL
     get_info("Device", :cl_uint, "preferred_vector_width_long")
     get_info("Device", :cl_uint, "preferred_vector_width_float")
     get_info("Device", :cl_uint, "preferred_vector_width_double")
-    get_info("Device", :string,  "profile")
+    get_info("Device", :string,  "profile", true)
     get_info("Device", :size_t,  "profiling_timer_resolution")
     get_info("Device", :cl_command_queue_properties, "queue_properties")
     get_info("Device", :cl_device_fp_config,         "single_fp_config")
-    get_info("Device", :cl_device_type, "type")
-    get_info("Device", :string,         "vendor")
-    get_info("Device", :cl_uint,        "vendor_id")
-    get_info("Device", :string,         "version")
+    get_info("Device", :cl_device_type, "type", true)
+    get_info("Device", :string,         "vendor", true)
+    get_info("Device", :cl_uint,        "vendor_id", true)
+    get_info("Device", :string,         "version", true)
 
     # returs a floating point number corresponding to the OpenCL version of the Device
     def version_number
@@ -140,6 +141,7 @@ module OpenCL
     module OpenCL11
       extend InnerGenerator
 
+      get_info("Device", :cl_uint, "preferred_vector_width_half")
       get_info("Device", :cl_bool, "host_unified_memory")
       get_info("Device", :cl_uint, "native_vector_width_char")
       get_info("Device", :cl_uint, "native_vector_width_short")

data/lib/opencl_ruby_ffi/Event.rb

@@ -77,23 +77,31 @@ module OpenCL
 
     # Returns the CommandQueue associated with the Event, if it exists
     def command_queue
+      return @_command_queue if @_command_queue
       ptr = MemoryPointer::new( CommandQueue )
       error = OpenCL.clGetEventInfo(self, COMMAND_QUEUE, CommandQueue.size, ptr, nil)
       error_check(error)
       pt = ptr.read_pointer
       if pt.null? then
-        return nil
+        @_command_queue = nil
       else
-        return CommandQueue::new( pt )
+        @_command_queue = CommandQueue::new( pt )
       end
+      @_command_queue
     end
 
-    get_info("Event", :cl_command_type, "command_type")
+    get_info("Event", :cl_command_type, "command_type", true)
 
     def context
       return command_queue.context
     end
 
+    # Returns the Platform associated with the Event
+    def platform
+      return @_platform if @_platform
+      @_platform = self.context.platform
+    end
+
     # Returns a CommandExecutionStatus corresponding to the status of the command associtated with the Event
     def command_execution_status
       ptr = MemoryPointer::new( :cl_int )
@@ -140,10 +148,11 @@ module OpenCL
 
       # Returns the Context associated with the Event
       def context
+        return @_context if @_context
         ptr = MemoryPointer::new( Context )
         error = OpenCL.clGetEventInfo(self, CONTEXT, Context.size, ptr, nil)
         error_check(error)
-        return Context::new( ptr.read_pointer )
+        @_context = Context::new( ptr.read_pointer )
       end
 
       # Sets the satus of Event (a user event) to the given execution status

data/lib/opencl_ruby_ffi/Kernel.rb

@@ -64,6 +64,11 @@ module OpenCL
       # Returns the Kernel this Arg belongs to
       attr_reader :kernel
 
+      # Returns the Platform associated with this Arg
+      def platform
+        kernel.platform
+      end
+
       if ExtendedStruct::const_get(:FORCE_EXTENSIONS_LOADING) then
 
         def self.register_extension(name, mod, cond)
@@ -108,24 +113,27 @@ module OpenCL
 
         # Returns an AddressQualifier corresponding to the Arg
         def address_qualifier
+          return @_address_qualifier if @_address_qualifier
           error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
           ptr = MemoryPointer::new( :cl_kernel_arg_address_qualifier )
           error = OpenCL.clGetKernelArgInfo(@kernel, @index, ADDRESS_QUALIFIER, ptr.size, ptr, nil)
           error_check(error)
-          return AddressQualifier::new( ptr.read_cl_kernel_arg_address_qualifier )
+          @_address_qualifier = AddressQualifier::new( ptr.read_cl_kernel_arg_address_qualifier )
         end
 
         # Returns an AccessQualifier corresponding to the Arg
         def access_qualifier
+          return @_access_qualifier if @_access_qualifier
           error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
           ptr = MemoryPointer::new( :cl_kernel_arg_access_qualifier )
           error = OpenCL.clGetKernelArgInfo(@kernel, @index, ACCESS_QUALIFIER, ptr.size, ptr, nil)
           error_check(error)
-          return AccessQualifier::new( ptr.read_cl_kernel_arg_access_qualifier )
+          @_access_qualifier = AccessQualifier::new( ptr.read_cl_kernel_arg_access_qualifier )
         end
 
         # Returns a String corresponding to the Arg type name
         def type_name
+          return @_type_name if @_type_name
           error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
           ptr1 = MemoryPointer::new( :size_t, 1)
           error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_NAME, 0, nil, ptr1)
@@ -133,20 +141,22 @@ module OpenCL
           ptr2 = MemoryPointer::new( ptr1.read_size_t )
           error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_NAME, ptr1.read_size_t, ptr2, nil)
           error_check(error)
-          return ptr2.read_string
+          @_type_name = ptr2.read_string
         end
 
         # Returns a TypeQualifier corresponding to the Arg
         def type_qualifier
+          return @_type_qualifier if @_type_qualifier
           error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
           ptr = MemoryPointer::new( :cl_kernel_arg_type_qualifier )
           error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_QUALIFIER, ptr.size, ptr, nil)
           error_check(error)
-          return TypeQualifier::new( ptr.read_cl_kernel_arg_type_qualifier )
+          @_type_qualifier = TypeQualifier::new( ptr.read_cl_kernel_arg_type_qualifier )
         end
 
         # Returns a String corresponding to the Arg name
         def name
+          return @_name if @_name
           error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
           ptr1 = MemoryPointer::new( :size_t, 1)
           error = OpenCL.clGetKernelArgInfo(@kernel, @index, NAME, 0, nil, ptr1)
@@ -154,7 +164,7 @@ module OpenCL
           ptr2 = MemoryPointer::new( ptr1.read_size_t )
           error = OpenCL.clGetKernelArgInfo(@kernel, @index, NAME, ptr1.read_size_t, ptr2, nil)
           error_check(error)
-          return ptr2.read_string
+          @_name = ptr2.read_string
         end
 
         alias to_s name
@@ -175,27 +185,35 @@ module OpenCL
       return a
     end
 
-    get_info("Kernel", :string, "function_name")
+    get_info("Kernel", :string, "function_name", true)
     alias name function_name
     alias to_s name
 
-    get_info("Kernel", :cl_uint, "num_args")
+    get_info("Kernel", :cl_uint, "num_args", true)
     get_info("Kernel", :cl_uint, "reference_count")
 
+    # Returns the Platform associated with the Kernel
+    def platform
+      return @_platform if @_platform
+      @_platform = self.context.platform
+    end
+
     # Returns the Context the Kernel is associated with
     def context
+      return @_context if @_context
       ptr = MemoryPointer::new( Context )
       error = OpenCL.clGetKernelInfo(self, CONTEXT, Context.size, ptr, nil)
       error_check(error)
-      return Context::new( ptr.read_pointer )
+      @_context = Context::new( ptr.read_pointer )
     end
 
     # Returns the Program the Kernel was created from
     def program
+      return @_program if @_program
       ptr = MemoryPointer::new( Program )
       error = OpenCL.clGetKernelInfo(self, PROGRAM, Program.size, ptr, nil)
       error_check(error)
-      return Program::new(ptr.read_pointer)
+      @_program = Program::new(ptr.read_pointer)
     end
 
     def work_group_size(device = program.devices.first)
@@ -268,6 +286,7 @@ module OpenCL
       ##
       # returns a String containing the attributes qualifier used at kernel definition
       def attributes
+        return @_attributes if @_attributes
         attributes_size = MemoryPointer::new( :size_t )
         error = OpenCL.clGetKernelInfo( self, ATTRIBUTES, 0, nil, attributes_size)
         error_check(error)
@@ -275,7 +294,7 @@ module OpenCL
         error = OpenCL.clGetKernelInfo( self, ATTRIBUTES, attributes_size.read_size_t, attr, nil)
         error_check(error)
         attr_string = attr.read_string
-        return attr_string.split(" ")
+        @_attributes = attr_string.split(" ")
       end
 
       def global_work_size(device = program.devices.first)

data/lib/opencl_ruby_ffi/Mem.rb

@@ -13,8 +13,16 @@ module OpenCL
   #
   # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
   def self.set_mem_object_destructor_callback( memobj, options = {}, &block )
-    @@callbacks.push( block ) if block
-    error = clSetMemObjectDestructorCallback( memobj, block, options[:user_data] )
+    if block
+      wrapper_block = lambda { |p, u|
+        block.call(p, u)
+        @@callbacks.delete(wrapper_block)
+      }
+      @@callbacks[wrapper_block] = options[:user_data]
+    else
+      wrapper_block = nil
+    end
+    error = clSetMemObjectDestructorCallback( memobj, wrapper_block, options[:user_data] )
     error_check(error)
     return memobj
   end
@@ -29,24 +37,26 @@ module OpenCL
       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", :cl_mem_object_type, "type", true)
+    get_info("Mem", :cl_mem_flags, "flags", true)
+    get_info("Mem", :size_t, "size", true)
     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
+      return @_context if @_context
       ptr = MemoryPointer::new( Context )
       error = OpenCL.clGetMemObjectInfo(self, CONTEXT, Context.size, ptr, nil)
       error_check(error)
-      return Context::new( ptr.read_pointer )
+      @_context = Context::new( ptr.read_pointer )
     end
 
     # Returns the Platform associated to the Mem
     def platform
-      return self.context.platform
+      return @_platform if @_platform
+      @_platform = self.context.platform
     end
 
     # Returns the texture_target argument specified in create_from_GL_texture for Mem
@@ -88,7 +98,7 @@ module OpenCL
     module OpenCL11
       extend InnerGenerator
 
-      get_info("Mem", :size_t, "offset")
+      get_info("Mem", :size_t, "offset", true)
 
       # Returns the Buffer this Buffer was created from using create_sub_buffer
       def associated_memobject
@@ -119,7 +129,7 @@ module OpenCL
     module OpenCL20
       extend InnerGenerator
 
-      get_info("Mem", :cl_bool, "uses_svm_pointer")
+      get_info("Mem", :cl_bool, "uses_svm_pointer", true)
 
     end