opencl_ruby_ffi 1.3.9 → 1.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b82499588d782647276b70a17225849c4468bb0c3619191fcba4bb15729318a
-  data.tar.gz: 3b015990606ee221a9e7288b2f1b99bfdae814ae3016f8142fb1044df3b3ec3b
+  metadata.gz: ed02c06ec493e3a80c58182e631294ddeaa05d2f5a2236607a8431dc2684d4ab
+  data.tar.gz: 6f0404c434de4e4d392b1f3e641acc2e08010aa06c5f3d9cc035c52dead6070f
 SHA512:
-  metadata.gz: 28148b57ac0b7cf8e8b619ed50e94c0bf5af77cfebad6fdae788efc23e90850bfe439a64f50270573367729a7fd47751a1fe3d75e8dd5b0405c9ffeb2b4012f6
-  data.tar.gz: 6b11039332b1c93141c350ab5b0a642521d0019e5bc1670af22daad333d85a4f32db8fa18d7bba5d2032944300ecdba6167903f623661f448b74fe45bd4a6948
+  metadata.gz: 84cb00cb6e7a753eb365e64aac09dcf7fcd488aa5f9de3abf5685ddce81bdee6b44a7ea5548257e441c986ecb0f50ed9023c264cb51eede26100d03f36fbe2b7
+  data.tar.gz: 89e804309e0e092daacb1e614c9cb79467198c2259051a3ceaab101552bcd49969767920e6db34894bf53b73ec53ad2cd2eb935cb7946c47f2a0c274918c420f

data/lib/opencl_ruby_ffi/CommandQueue.rb

@@ -1072,8 +1072,7 @@ module OpenCL
 
     # Returns the Platform associated with the CommandQueue
     def platform
-      return @_platform if @_platform
-      @_platform = self.context.platform
+      @_platform ||= self.context.platform
     end
 
     # Returns the Context associated to the CommandQueue

data/lib/opencl_ruby_ffi/Context.rb

@@ -116,26 +116,25 @@ 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
-      @_num_devices = d_n
+      @_num_devices ||= begin
+        ptr = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetContextInfo(self, DEVICES, 0, nil, ptr)
+        error_check(error)
+        ptr.read_size_t / Platform.size
+      end
     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)
-      @_devices = ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
-        Device::new(device_ptr)
-      }
-      return @_devices
+      @_devices ||= begin
+        n = self.num_devices
+        ptr2 = MemoryPointer::new( Device, n )
+        error = OpenCL.clGetContextInfo(self, DEVICES, Device.size*n, ptr2, nil)
+        error_check(error)
+        ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
+          Device::new(device_ptr)
+        }
+      end
     end
 
     ##
@@ -169,8 +168,7 @@ module OpenCL
 
     # Returns the platform associated to the Context
     def platform
-      return @_platform if @_platform
-      @_platform = self.devices.first.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

@@ -107,11 +107,12 @@ module OpenCL
 
     # 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)
-      @_platform = OpenCL::Platform::new(ptr.read_pointer)
+      @_platform ||= begin
+        ptr = MemoryPointer::new( OpenCL::Platform )
+        error = OpenCL.clGetDeviceInfo(self, PLATFORM, OpenCL::Platform.size, ptr, nil)
+        error_check(error)
+        OpenCL::Platform::new(ptr.read_pointer)
+      end
     end
 
     get_info("Device", :cl_uint, "preferred_vector_width_char")
@@ -158,8 +159,6 @@ module OpenCL
         n = ver.scan(/OpenCL C (\d+\.\d+)/)
         return n.first.first.to_f
       end
-
-      get_info("Device", :cl_uint, "preferred_vector_width_half")
  
     end
 

data/lib/opencl_ruby_ffi/Event.rb

@@ -77,17 +77,17 @@ 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
-        @_command_queue = nil
-      else
-        @_command_queue = CommandQueue::new( pt )
+      @_command_queue ||= begin
+        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
+          nil
+        else
+          CommandQueue::new( pt )
+        end
       end
-      @_command_queue
     end
 
     get_info("Event", :cl_command_type, "command_type", true)
@@ -98,8 +98,7 @@ module OpenCL
 
     # Returns the Platform associated with the Event
     def platform
-      return @_platform if @_platform
-      @_platform = self.context.platform
+      @_platform ||= self.context.platform
     end
 
     # Returns a CommandExecutionStatus corresponding to the status of the command associtated with the Event
@@ -148,11 +147,12 @@ 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)
-        @_context = Context::new( ptr.read_pointer )
+        @_context ||= begin
+          ptr = MemoryPointer::new( Context )
+          error = OpenCL.clGetEventInfo(self, CONTEXT, Context.size, ptr, nil)
+          error_check(error)
+          Context::new( ptr.read_pointer )
+        end
       end
 
       # Sets the satus of Event (a user event) to the given execution status

data/lib/opencl_ruby_ffi/Kernel.rb

@@ -113,58 +113,63 @@ 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)
-          @_address_qualifier = AddressQualifier::new( ptr.read_cl_kernel_arg_address_qualifier )
+          @_address_qualifier ||= begin
+            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)
+            AddressQualifier::new( ptr.read_cl_kernel_arg_address_qualifier )
+          end
         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)
-          @_access_qualifier = AccessQualifier::new( ptr.read_cl_kernel_arg_access_qualifier )
+          @_access_qualifier ||= begin
+            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)
+            AccessQualifier::new( ptr.read_cl_kernel_arg_access_qualifier )
+          end
         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)
-          error_check(error)
-          ptr2 = MemoryPointer::new( ptr1.read_size_t )
-          error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_NAME, ptr1.read_size_t, ptr2, nil)
-          error_check(error)
-          @_type_name = ptr2.read_string
+          @_type_name ||= begin
+            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)
+            error_check(error)
+            ptr2 = MemoryPointer::new( ptr1.read_size_t )
+            error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_NAME, ptr1.read_size_t, ptr2, nil)
+            error_check(error)
+            ptr2.read_string
+          end
         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)
-          @_type_qualifier = TypeQualifier::new( ptr.read_cl_kernel_arg_type_qualifier )
+          @_type_qualifier ||= begin
+            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)
+            TypeQualifier::new( ptr.read_cl_kernel_arg_type_qualifier )
+          end
         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)
-          error_check(error)
-          ptr2 = MemoryPointer::new( ptr1.read_size_t )
-          error = OpenCL.clGetKernelArgInfo(@kernel, @index, NAME, ptr1.read_size_t, ptr2, nil)
-          error_check(error)
-          @_name = ptr2.read_string
+          @_name ||= begin
+            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)
+            error_check(error)
+            ptr2 = MemoryPointer::new( ptr1.read_size_t )
+            error = OpenCL.clGetKernelArgInfo(@kernel, @index, NAME, ptr1.read_size_t, ptr2, nil)
+            error_check(error)
+            ptr2.read_string
+          end
         end
 
         alias to_s name
@@ -194,26 +199,27 @@ module OpenCL
 
     # Returns the Platform associated with the Kernel
     def platform
-      return @_platform if @_platform
-      @_platform = self.context.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)
-      @_context = Context::new( ptr.read_pointer )
+      @_context ||= begin
+        ptr = MemoryPointer::new( Context )
+        error = OpenCL.clGetKernelInfo(self, CONTEXT, Context.size, ptr, nil)
+        error_check(error)
+        Context::new( ptr.read_pointer )
+      end
     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)
-      @_program = Program::new(ptr.read_pointer)
+      @_program ||= begin
+        ptr = MemoryPointer::new( Program )
+        error = OpenCL.clGetKernelInfo(self, PROGRAM, Program.size, ptr, nil)
+        error_check(error)
+        Program::new(ptr.read_pointer)
+      end
     end
 
     def work_group_size(device = program.devices.first)
@@ -286,15 +292,16 @@ 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)
-        attr = MemoryPointer::new( attributes_size.read_size_t )
-        error = OpenCL.clGetKernelInfo( self, ATTRIBUTES, attributes_size.read_size_t, attr, nil)
-        error_check(error)
-        attr_string = attr.read_string
-        @_attributes = attr_string.split(" ")
+        @_attributes ||= begin
+          attributes_size = MemoryPointer::new( :size_t )
+          error = OpenCL.clGetKernelInfo( self, ATTRIBUTES, 0, nil, attributes_size)
+          error_check(error)
+          attr = MemoryPointer::new( attributes_size.read_size_t )
+          error = OpenCL.clGetKernelInfo( self, ATTRIBUTES, attributes_size.read_size_t, attr, nil)
+          error_check(error)
+          attr_string = attr.read_string
+          attr_string.split(" ")
+        end
       end
 
       def global_work_size(device = program.devices.first)

data/lib/opencl_ruby_ffi/Mem.rb

@@ -46,17 +46,17 @@ module OpenCL
 
     # 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)
-      @_context = Context::new( ptr.read_pointer )
+      @_context ||= begin
+       ptr = MemoryPointer::new( Context )
+        error = OpenCL.clGetMemObjectInfo(self, CONTEXT, Context.size, ptr, nil)
+        error_check(error)
+        Context::new( ptr.read_pointer )
+      end
     end
 
     # Returns the Platform associated to the Mem
     def platform
-      return @_platform if @_platform
-      @_platform = self.context.platform
+      @_platform ||= self.context.platform
     end
 
     # Returns the texture_target argument specified in create_from_GL_texture for Mem

data/lib/opencl_ruby_ffi/Platform.rb

@@ -63,18 +63,18 @@ module OpenCL
 
   # Returns an Array of Platform containing the available OpenCL platforms
   def self.get_platforms
-    return @_platforms if @_platforms
-    ptr1 = MemoryPointer::new(:cl_uint , 1)
+    @_platforms ||= begin
+      ptr1 = MemoryPointer::new(:cl_uint , 1)
     
-    error = clGetPlatformIDs(0, nil, ptr1)
-    error_check(error)
-    ptr2 = MemoryPointer::new(:pointer, ptr1.read_uint)
-    error = clGetPlatformIDs(ptr1.read_uint(), ptr2, nil)
-    error_check(error)
-    @_platforms = ptr2.get_array_of_pointer(0,ptr1.read_uint()).collect { |platform_ptr|
-      Platform::new(platform_ptr, false)
-    }
-    return @_platforms
+      error = clGetPlatformIDs(0, nil, ptr1)
+      error_check(error)
+      ptr2 = MemoryPointer::new(:pointer, ptr1.read_uint)
+      error = clGetPlatformIDs(ptr1.read_uint(), ptr2, nil)
+      error_check(error)
+      ptr2.get_array_of_pointer(0,ptr1.read_uint()).collect { |platform_ptr|
+        Platform::new(platform_ptr, false)
+      }
+    end
   end
 
   class << self

data/lib/opencl_ruby_ffi/Program.rb

@@ -280,7 +280,11 @@ module OpenCL
       build_status.each { |d,s|
         success |= true if s.to_i == BuildStatus::SUCCESS
       }
-      return "#<#{self.class.name}: #{success ? kernel_names : ""}>"
+      begin
+        return "#<#{self.class.name}: #{success ? kernel_names : ""}>"
+      rescue
+        return "#<#{self.class.name}: >"
+      end
     end
 
     alias_method :orig_method_missing, :method_missing
@@ -304,17 +308,17 @@ module OpenCL
 
     # Returns the Platform associated with the Program
     def platform
-      return @_platform if @_platform
-      @_platform = self.context.platform
+      @_platform ||= self.context.platform
     end
 
     # Returns the Context the Program is associated to
     def context
-      return @_context if @_context
-      ptr = MemoryPointer::new( Context )
-      error = OpenCL.clGetProgramInfo(self, CONTEXT, Context.size, ptr, nil)
-      error_check(error)
-      @_context = Context::new( ptr.read_pointer )
+      @_context ||= begin
+        ptr = MemoryPointer::new( Context )
+        error = OpenCL.clGetProgramInfo(self, CONTEXT, Context.size, ptr, nil)
+        error_check(error)
+        Context::new( ptr.read_pointer )
+      end
     end
 
     get_info("Program", :cl_uint, "num_devices", true)
@@ -322,15 +326,15 @@ module OpenCL
 
     # Returns the Array of Device the Program is associated with
     def devices
-      return @_devices if @_devices
-      n = self.num_devices
-      ptr2 = MemoryPointer::new( Device, n )
-      error = OpenCL.clGetProgramInfo(self, DEVICES, Device.size*n, ptr2, nil)
-      error_check(error)
-      @_devices = ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
-        Device::new(device_ptr)
-      }
-      return @_devices
+      @_devices ||= begin
+        n = self.num_devices
+        ptr2 = MemoryPointer::new( Device, n )
+        error = OpenCL.clGetProgramInfo(self, DEVICES, Device.size*n, ptr2, nil)
+        error_check(error)
+        ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
+          Device::new(device_ptr)
+        }
+      end
     end
 
     get_info("Program", :string, "source")

data/lib/opencl_ruby_ffi/Sampler.rb

@@ -71,11 +71,12 @@ module OpenCL
 
     # Returns the context associated with the Sampler
     def context
-      return @_context if @_context
-      ptr = MemoryPointer::new( Context )
-      error = OpenCL.clGetSamplerInfo(self, CONTEXT, Context.size, ptr, nil)
-      error_check(error)
-      @_context = Context::new( ptr.read_pointer )
+      @_context ||= begin
+        ptr = MemoryPointer::new( Context )
+        error = OpenCL.clGetSamplerInfo(self, CONTEXT, Context.size, ptr, nil)
+        error_check(error)
+        Context::new( ptr.read_pointer )
+      end
     end
 
     get_info("Sampler", :cl_uint, "reference_count")

data/lib/opencl_ruby_ffi/intel/unified_shared_memory_preview.rb

@@ -228,6 +228,23 @@ module OpenCL
       get_info("Device", :cl_unified_shared_memory_capabilities_intel, "device_shared_mem_capabilities_intel")
       get_info("Device", :cl_unified_shared_memory_capabilities_intel, "cross_device_mem_capabilities_intel")
       get_info("Device", :cl_unified_shared_memory_capabilities_intel, "shared_system_mem_capabilities_intel")
+
+      def clGetDeviceGlobalVariablePointerINTEL
+        @_clGetDeviceGlobalVariablePointerINTEL ||= begin
+          p = platform.get_extension_function("clGetDeviceGlobalVariablePointerINTEL", :cl_int, [Device, Program, :string, :pointer, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
+      end
+
+      def get_global_variable_pointer_intel(program, name)
+        pSize = MemoryPointer::new(:size_t)
+        pAddr = MemoryPointer::new(:pointer)
+        error = clGetDeviceGlobalVariablePointerINTEL.call(self, program, name, pAddr, pSize)
+        error_check(error)
+        return USMPointer::new(pAddr.read_pointer.slice(0, pSize.read_size_t), self)
+      end
+
     end
     register_extension( :cl_intel_unified_shared_memory_preview, UnifiedSharedMemoryPreviewINTEL, "extensions.include?(\"cl_intel_unified_shared_memory_preview\")" )
   end
@@ -282,38 +299,43 @@ module OpenCL
       extend InnerGenerator
 
       def clGetMemAllocInfoINTEL
-        return @_clGetMemAllocInfoINTEL if @_clGetMemAllocInfoINTEL
-        @_clGetMemAllocInfoINTEL = platform.get_extension_function("clGetMemAllocInfoINTEL", :cl_int, [Context, :pointer, :cl_mem_info_intel, :size_t, :pointer, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clGetMemAllocInfoINTEL
-        return @_clGetMemAllocInfoINTEL
+        @_clGetMemAllocInfoINTEL ||= begin
+          p = platform.get_extension_function("clGetMemAllocInfoINTEL", :cl_int, [Context, :pointer, :cl_mem_info_intel, :size_t, :pointer, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def clHostMemAllocINTEL
-        return @_clHostMemAllocINTEL if @_clHostMemAllocINTEL
-        @_clHostMemAllocINTEL = platform.get_extension_function("clHostMemAllocINTEL", :pointer, [Context, :pointer, :size_t, :cl_uint, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clHostMemAllocINTEL
-        return @_clHostMemAllocINTEL
+        @_clHostMemAllocINTEL ||= begin
+          p = platform.get_extension_function("clHostMemAllocINTEL", :pointer, [Context, :pointer, :size_t, :cl_uint, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def clDeviceMemAllocINTEL
-        return @_clDeviceMemAllocINTEL if @_clDeviceMemAllocINTEL
-        @_clDeviceMemAllocINTEL = platform.get_extension_function("clDeviceMemAllocINTEL", :pointer, [Context, Device, :pointer, :size_t, :cl_uint, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clDeviceMemAllocINTEL
-        return @_clDeviceMemAllocINTEL
+        @_clDeviceMemAllocINTEL ||= begin
+          p = platform.get_extension_function("clDeviceMemAllocINTEL", :pointer, [Context, Device, :pointer, :size_t, :cl_uint, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def clSharedMemAllocINTEL
-        return @_clSharedMemAllocINTEL if @_clSharedMemAllocINTEL
-        @_clSharedMemAllocINTEL = platform.get_extension_function("clSharedMemAllocINTEL", :pointer, [Context, Device, :pointer, :size_t, :cl_uint, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clSharedMemAllocINTEL
-        return @_clSharedMemAllocINTEL
+        @_clSharedMemAllocINTEL ||= begin
+          p = platform.get_extension_function("clSharedMemAllocINTEL", :pointer, [Context, Device, :pointer, :size_t, :cl_uint, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def clMemFreeINTEL
-        return @_clMemFreeINTEL if @_clMemFreeINTEL
-        @_clMemFreeINTEL = platform.get_extension_function("clMemFreeINTEL", :cl_int, [Context, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clMemFreeINTEL
-        return @_clMemFreeINTEL
+        return @_clMemFreeINTEL ||= begin
+          p = platform.get_extension_function("clMemFreeINTEL", :cl_int, [Context, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def get_mem_properties_intel(properties)
@@ -414,10 +436,11 @@ module OpenCL
       extend InnerGenerator
 
       def clSetKernelArgMemPointerINTEL
-        return @_clSetKernelArgMemPointerINTEL if @_clSetKernelArgMemPointerINTEL
-        @_clSetKernelArgMemPointerINTEL = context.platform.get_extension_function("clSetKernelArgMemPointerINTEL", :cl_int, Kernel, :cl_uint, :pointer)
-        error_check(OpenCL::INVALID_OPERATION) unless @_clSetKernelArgMemPointerINTEL
-        return @_clSetKernelArgMemPointerINTEL
+        @_clSetKernelArgMemPointerINTEL ||= begin
+          p = context.platform.get_extension_function("clSetKernelArgMemPointerINTEL", :cl_int, Kernel, :cl_uint, :pointer)
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def set_arg_mem_pointer_intel(index, usm_pointer)
@@ -508,31 +531,35 @@ module OpenCL
       extend InnerGenerator
 
       def clEnqueueMemFillINTEL
-        return @_clEnqueueMemFillINTEL if @_clEnqueueMemFillINTEL
-        @_clEnqueueMemFillINTEL = platform.get_extension_function("clEnqueueMemFillINTEL", :cl_int, [CommandQueue, :pointer, :pointer, :size_t, :size_t, :cl_uint, :pointer, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clEnqueueMemFillINTEL
-        return @_clEnqueueMemFillINTEL
+        @_clEnqueueMemFillINTEL ||= begin
+          p = platform.get_extension_function("clEnqueueMemFillINTEL", :cl_int, [CommandQueue, :pointer, :pointer, :size_t, :size_t, :cl_uint, :pointer, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def clEnqueueMemcpyINTEL
-        return @_clEnqueueMemcpyINTEL if @_clEnqueueMemcpyINTEL
-        @_clEnqueueMemcpyINTEL = platform.get_extension_function("clEnqueueMemcpyINTEL", :cl_int, [CommandQueue, :cl_bool, :pointer, :pointer, :size_t, :cl_uint, :pointer, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clEnqueueMemcpyINTEL
-        return @_clEnqueueMemcpyINTEL
+        @_clEnqueueMemcpyINTEL ||= begin
+          p = platform.get_extension_function("clEnqueueMemcpyINTEL", :cl_int, [CommandQueue, :cl_bool, :pointer, :pointer, :size_t, :cl_uint, :pointer, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def clEnqueueMigrateMemINTEL
-        return @_clEnqueueMigrateMemINTEL if @_clEnqueueMigrateMemINTEL
-        @_clEnqueueMigrateMemINTEL = platform.get_extension_function("clEnqueueMigrateMemINTEL", :cl_int, [CommandQueue, :pointer, :size_t, :cl_mem_migration_flags_intel, :cl_uint, :pointer, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clEnqueueMemcpyINTEL
-        return @_clEnqueueMemcpyINTEL
+        @_clEnqueueMigrateMemINTEL ||= begin
+          p = platform.get_extension_function("clEnqueueMigrateMemINTEL", :cl_int, [CommandQueue, :pointer, :size_t, :cl_mem_migration_flags_intel, :cl_uint, :pointer, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def clEnqueueMemAdviseINTEL
-        return @_clEnqueueMemAdviseINTEL if @_clEnqueueMemAdviseINTEL
-        @_clEnqueueMemAdviseINTEL = platform.get_extension_function("clEnqueueMemAdviseINTEL", :cl_int, [CommandQueue, :pointer, :size_t, :cl_mem_advice_intel, :cl_uint, :pointer, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless @_clEnqueueMemAdviseINTEL
-        return @_clEnqueueMemAdviseINTEL
+        @_clEnqueueMemAdviseINTEL ||= begin
+          p = platform.get_extension_function("clEnqueueMemAdviseINTEL", :cl_int, [CommandQueue, :pointer, :size_t, :cl_mem_advice_intel, :cl_uint, :pointer, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless p
+          p
+        end
       end
 
       def enqueue_mem_fill_intel(usm_ptr, pattern, options = {})

data/lib/opencl_ruby_ffi/opencl_ruby_ffi_base.rb

@@ -388,22 +388,22 @@ module OpenCL
       if memoizable
       s = <<EOF
       def #{name.downcase}
-        return @_#{name.downcase} if @_#{name.downcase}
-        f = platform.get_extension_function("#{function}", :cl_int, [#{klass}, :cl_uint, :size_t, :pointer, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless f
-
-        ptr1 = MemoryPointer::new(:size_t, 1)
-        error = f.call(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
-        error_check(error)
-        ptr2 = MemoryPointer::new(ptr1.read_size_t)
-        error = f.call(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
-        error_check(error)
-        if(convert_type(:#{type})) then
-          @_#{name.downcase} = convert_type(:#{type})::new(ptr2.read_#{type})
-        else
-          @_#{name.downcase} = ptr2.read_#{type}
+        @_#{name.downcase} ||= begin
+          f = platform.get_extension_function("#{function}", :cl_int, [#{klass}, :cl_uint, :size_t, :pointer, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless f
+
+          ptr1 = MemoryPointer::new(:size_t, 1)
+          error = f.call(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
+          error_check(error)
+          ptr2 = MemoryPointer::new(ptr1.read_size_t)
+          error = f.call(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
+          error_check(error)
+          if(convert_type(:#{type})) then
+            convert_type(:#{type})::new(ptr2.read_#{type})
+          else
+            ptr2.read_#{type}
+          end
         end
-        return @_#{name.downcase}
       end
 EOF
       else
@@ -444,23 +444,23 @@ EOF
       if memoizable
       s = <<EOF
       def #{name.downcase}
-        return @_#{name.downcase} if @_#{name.downcase}
-        f = platform.get_extension_function("#{function}", :cl_int, [#{klass}, :cl_uint, :size_t, :pointer, :pointer])
-        error_check(OpenCL::INVALID_OPERATION) unless f
-
-        ptr1 = MemoryPointer::new(:size_t, 1)
-        error = f.call(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
-        error_check(error)
-        ptr2 = MemoryPointer::new(ptr1.read_size_t)
-        error = f.call(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
-        error_check(error)
-        arr = ptr2.get_array_of_#{type}(0, ptr1.read_size_t / OpenCL.find_type(:#{type}).size)
-        if(convert_type(:#{type})) then
-          @_#{name.downcase} = arr.collect { |e| convert_type(:#{type})::new(e) }
-        else
-          @_#{name.downcase} = arr
+        @_#{name.downcase} ||= begin
+          f = platform.get_extension_function("#{function}", :cl_int, [#{klass}, :cl_uint, :size_t, :pointer, :pointer])
+          error_check(OpenCL::INVALID_OPERATION) unless f
+
+          ptr1 = MemoryPointer::new(:size_t, 1)
+          error = f.call(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
+          error_check(error)
+          ptr2 = MemoryPointer::new(ptr1.read_size_t)
+          error = f.call(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
+          error_check(error)
+          arr = ptr2.get_array_of_#{type}(0, ptr1.read_size_t / OpenCL.find_type(:#{type}).size)
+          if(convert_type(:#{type})) then
+            arr.collect { |e| convert_type(:#{type})::new(e) }
+          else
+            arr
+          end
         end
-        return @_#{name.downcase}
       end
 EOF
       else
@@ -504,19 +504,19 @@ EOF
       if memoizable
       s = <<EOF
       def #{name.downcase}
-        return @_#{name.downcase} if @_#{name.downcase}
-        ptr1 = MemoryPointer::new(:size_t, 1)
-        error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
-        error_check(error)
-        ptr2 = MemoryPointer::new(ptr1.read_size_t)
-        error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
-        error_check(error)
-        if(convert_type(:#{type})) then
-          @_#{name.downcase} = convert_type(:#{type})::new(ptr2.read_#{type})
-        else
-          @_#{name.downcase} = ptr2.read_#{type}
+        @_#{name.downcase} ||= begin
+          ptr1 = MemoryPointer::new(:size_t, 1)
+          error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
+          error_check(error)
+          ptr2 = MemoryPointer::new(ptr1.read_size_t)
+          error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
+          error_check(error)
+          if(convert_type(:#{type})) then
+            convert_type(:#{type})::new(ptr2.read_#{type})
+          else
+            ptr2.read_#{type}
+          end
         end
-        return @_#{name.downcase}
       end
 EOF
       else
@@ -556,20 +556,20 @@ EOF
       if memoizable
         s = <<EOF
       def #{name.downcase}
-        return @_#{name.downcase} if @_#{name.downcase}
-        ptr1 = MemoryPointer::new(:size_t, 1)
-        error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
-        error_check(error)
-        ptr2 = MemoryPointer::new(ptr1.read_size_t)
-        error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
-        error_check(error)
-        arr = ptr2.get_array_of_#{type}(0, ptr1.read_size_t / OpenCL.find_type(:#{type}).size)
-        if(convert_type(:#{type})) then
-          @_#{name.downcase} = arr.collect { |e| convert_type(:#{type})::new(e) }
-        else
-          @_#{name.downcase} = arr
+        @_#{name.downcase} ||= begin
+          ptr1 = MemoryPointer::new(:size_t, 1)
+          error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, 0, nil, ptr1)
+          error_check(error)
+          ptr2 = MemoryPointer::new(ptr1.read_size_t)
+          error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name.upcase}, ptr1.read_size_t, ptr2, nil)
+          error_check(error)
+          arr = ptr2.get_array_of_#{type}(0, ptr1.read_size_t / OpenCL.find_type(:#{type}).size)
+          if(convert_type(:#{type})) then
+            arr.collect { |e| convert_type(:#{type})::new(e) }
+          else
+            arr
+          end
         end
-        return @_#{name.downcase}
       end
 EOF
       else

data/lib/opencl_ruby_ffi/opencl_ruby_ffi_library.rb

@@ -6,16 +6,16 @@ module OpenCL
     else
       raise LoadError
     end
-  rescue LoadError => e
+  rescue LoadError
     begin
       ffi_lib "OpenCL"
-    rescue LoadError => e
+    rescue LoadError
       begin
         ffi_lib "libOpenCL.so.1"
-      rescue LoadError => e
+      rescue LoadError
         begin
           ffi_lib '/System/Library/Frameworks/OpenCL.framework/OpenCL'
-        rescue LoadError => e
+        rescue LoadError
           raise "OpenCL implementation not found!"
         end
       end
@@ -160,22 +160,22 @@ module OpenCL
               attach_function :clCreateImageWithProperties, [Context,:pointer,:cl_mem_flags,:pointer,:pointer,:pointer,:pointer], Mem
               callback :clSetContextDestructorCallback_notify, [Context.by_ref,:pointer], :void
               attach_function :clSetContextDestructorCallback, [Context,:clSetContextDestructorCallback_notify,:pointer], :cl_int
-            rescue NotFoundError => e
+            rescue NotFoundError
               warn "Warning OpenCL 2.2 loader detected!"
             end
-          rescue NotFoundError => e
+          rescue NotFoundError
             warn "Warning OpenCL 2.1 loader detected!"
           end
-        rescue NotFoundError => e
+        rescue NotFoundError
           warn "Warning OpenCL 2.0 loader detected!"
         end
-      rescue NotFoundError => e
+      rescue NotFoundError
         warn "Warning OpenCL 1.2 loader detected!"
       end
-    rescue NotFoundError => e
+    rescue NotFoundError
       warn "Warning OpenCL 1.1 loader detected!"
     end
-  rescue NotFoundError => e
+  rescue NotFoundError
       warn "Warning OpenCL 1.0 loader detected!"
   end
 end

data/opencl_ruby_ffi.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'opencl_ruby_ffi'
-  s.version = "1.3.9"
+  s.version = "1.3.10"
   s.author = "Brice Videau"
   s.email = "bvideau@anl.gov"
   s.homepage = "https://github.com/Nanosim-LIG/opencl-ruby"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opencl_ruby_ffi
 version: !ruby/object:Gem::Version
-  version: 1.3.9
+  version: 1.3.10
 platform: ruby
 authors:
 - Brice Videau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-08 00:00:00.000000000 Z
+date: 2021-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: narray
@@ -148,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.5
 signing_key: 
 specification_version: 4
 summary: Ruby OpenCL FFI bindings