opencl_ruby_ffi 1.3.7 → 1.3.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abb565a3d9a1e180eebf1e28ab06d330a4ae2477522ba2b22c0211bf7c720bc4
-  data.tar.gz: 2e47f057d7cf5a79a3972f8a3ab1ac7291827020c607c465d357b58824683ec5
+  metadata.gz: fdde36869013e898818c10e84618fc8af7efbfb37f65f0dc420a5cbcfe98e724
+  data.tar.gz: a1934b0c7beb47644793083adaa04765dcc8eb7cddf54fc51ee1f203ebf545c7
 SHA512:
-  metadata.gz: d144d10d5744d13cf235a2f0ff4b9fa2bb1df7d47fc4c9b4799c233d1f9e2dc71f30f66c84cdf4a55db197cb6a4175b654845ac6be97c03ed57ea4b931508a10
-  data.tar.gz: 29561be75358ae7ae658a365f602930ff62a4bf5854ca1a0f0547ff5b7c4703ca01bd19fc036b15b3a503a0b3990eaa482d0c95c66b0be1b388316fa09e3348b
+  metadata.gz: f0c9376a0dc33def8c99a553526f77755223ca2592b845713fad3567bd30b8e3c4af8a1630db4f30739ada00119f53b75ab16a5a13c323205c87410565e6d568
+  data.tar.gz: ade66f8ccb6bdfbfdd8a3e0a88878e129507317fd710bf52ec0425c96441d5982765e7e222c6c6c154a68ee7812e6cb144fa72aefcc35ada654899c69e2c40ef

data/lib/opencl_ruby_ffi.rb

@@ -2,6 +2,7 @@ require "opencl_ruby_ffi/opencl_types.rb"
 require "opencl_ruby_ffi/opencl_ruby_ffi_base_gen.rb"
 require "opencl_ruby_ffi/opencl_arithmetic_gen.rb"
 require "opencl_ruby_ffi/opencl_ruby_ffi_base.rb"
+require "opencl_ruby_ffi/opencl_ruby_ffi_library.rb"
 require "opencl_ruby_ffi/Context.rb"
 require "opencl_ruby_ffi/Platform.rb"
 require "opencl_ruby_ffi/Device.rb"

data/lib/opencl_ruby_ffi/Buffer.rb

@@ -13,11 +13,17 @@ module OpenCL
   # 
   # * +: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
+  # * +:properties+ - if provided, an array of :cl_mem_properties (OpenCL 3.0)
   def self.create_buffer( context, size, options = {} )
     flags = get_flags( options )
     host_ptr = options[:host_ptr]
     error = MemoryPointer::new( :cl_int )
-    buff = clCreateBuffer(context, flags, size, host_ptr, error)
+    if context.platform.version_number < 3.0 then
+      buff = clCreateBuffer(context, flags, size, host_ptr, error)
+    else
+      properties = get_mem_properties( options )
+      buff = clCreateBufferWithProperties(context, properties, flags, size, host_ptr, error)
+    end
     error_check(error.read_cl_int)
     return Buffer::new( buff, false )
   end

data/lib/opencl_ruby_ffi/CommandQueue.rb

@@ -566,7 +566,7 @@ module OpenCL
     objs = nil
     if num_objs > 0 then
       objs = MemoryPointer::new(  Mem, num_objs )
-      [mem_objects].flatten.each_with_index { |o, i|
+      [mem_objects].flatten.each_with_index { |e, i|
         objs[i].write_pointer(e)
       }
     end
@@ -600,7 +600,7 @@ module OpenCL
     objs = nil
     if num_objs > 0 then
       objs = MemoryPointer::new( Mem, num_objs )
-      [mem_objects].flatten.each_with_index { |o, i|
+      [mem_objects].flatten.each_with_index { |e, i|
         objs[i].write_pointer(e)
       }
     end
@@ -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
@@ -1790,10 +1789,17 @@ module OpenCL
 
     end
 
+    module OpenCL30
+      extend InnerGenerator
+
+      get_info_array("CommandQueue", :cl_queue_properties, "properties_array")
+    end
+
     register_extension( :v11, OpenCL11, "device.platform.version_number >= 1.1" )
     register_extension( :v12, OpenCL12, "device.platform.version_number >= 1.2" )
     register_extension( :v20, OpenCL20, "device.platform.version_number >= 2.0" )
     register_extension( :v21, OpenCL21, "device.platform.version_number >= 2.1" )
+    register_extension( :v30, OpenCL30, "device.platform.version_number >= 3.0" )
 
   end
 

data/lib/opencl_ruby_ffi/Context.rb

@@ -25,7 +25,16 @@ module OpenCL
     error = MemoryPointer::new( :cl_int )
     ptr = clCreateContext(properties, devs.size, pointer, block, user_data, error)
     error_check(error.read_cl_int)
-    return Context::new(ptr, false)
+    context = Context::new(ptr, false)
+    if block && context.platform.version_number >= 3.0
+      callback_destructor_callback = lambda { |c, u|
+        @@callbacks.delete(block)
+        @@callbacks.delete(callback_destructor_callback)
+      }
+      @@callbacks[callback_destructor_callback] = nil
+      context.set_destructor_callback(&callback_destructor_callback)
+    end
+    return context
   end
 
   # Creates an Context using devices of the selected type
@@ -49,7 +58,16 @@ module OpenCL
     error = MemoryPointer::new( :cl_int )
     ptr = clCreateContextFromType(properties, type, block, user_data, error)
     error_check(error.read_cl_int)
-    return Context::new(ptr, false)
+    context = Context::new(ptr, false)
+    if block && context.platform.version_number >= 3.0
+      callback_destructor_callback = lambda { |c, u|
+        @@callbacks.delete(block)
+        @@callbacks.delete(callback_destructor_callback)
+      }
+      @@callbacks[callback_destructor_callback] = nil
+      context.set_destructor_callback(&callback_destructor_callback)
+    end
+    return context
   end
 
   def self.set_default_device_command_queue( context, device, command_queue )
@@ -59,6 +77,32 @@ module OpenCL
     return context
   end
 
+  # Attaches a callback to context that will be called on context destruction
+  #
+  # ==== Attributes
+  #
+  # * +context+ - the Program to attach the callback to
+  # * +options+ - a hash containing named options
+  # * +block+ - if provided, a callback invoked when program is released. Signature of the callback is { |Pointer to the context, 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 self.set_context_destructor_callback( context, options = {}, &block )
+    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 = clSetContextDestructorCallback( context, wrapper_block, options[:user_data] )
+    error_check(error)
+    return context
+  end
+
   #Maps the cl_context object of OpenCL
   class Context
     include InnerInterface
@@ -72,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
 
     ##
@@ -125,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
@@ -459,16 +501,36 @@ module OpenCL
         return OpenCL.create_program_with_il(self, il)
       end
 
+      # 
       def set_default_device_command_queue( device, command_queue )
         return OpenCL.set_default_device_command_queue( self, device, command_queue )
       end
 
     end
 
+    module OpenCL30
+      
+      # Attaches a callback to context that will be called on context destruction
+      #
+      # ==== Attributes
+      #
+      # * +options+ - a hash containing named options
+      # * +block+ - if provided, a callback invoked when program is released. Signature of the callback is { |Pointer to the context, 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 = {}, &block )
+        OpenCL.set_context_destructor_callback( self, option, &block )
+        return self
+      end
+    end
+
     register_extension( :v11, OpenCL11, "platform.version_number >= 1.1" )
     register_extension( :v12, OpenCL12, "platform.version_number >= 1.2" )
     register_extension( :v20, OpenCL20, "platform.version_number >= 2.0" )
     register_extension( :v21, OpenCL21, "platform.version_number >= 2.1" )
+    register_extension( :v30, OpenCL30, "platform.version_number >= 3.0" )
 
   end
 

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
 
@@ -366,10 +365,90 @@ module OpenCL
 
     end
 
-    register_extension( :v11,  OpenCL11, "platform.version_number >= 1.1" )
-    register_extension( :v12,  OpenCL12, "platform.version_number >= 1.2" )
-    register_extension( :v20,  OpenCL20, "platform.version_number >= 2.0" )
-    register_extension( :v21,  OpenCL21, "platform.version_number >= 2.1" )
+    module OpenCL30
+      extend InnerGenerator
+      get_info("Device", :cl_device_atomic_capabilities, "atomic_memory_capabilities")
+      get_info("Device", :cl_device_atomic_capabilities, "atomic_fence_capabilities")
+      get_info("Device", :cl_bool, "non_uniform_work_group_support")
+      get_info("Device", :size_t, "preferred_work_group_size_multiple")
+      get_info("Device", :cl_bool, "work_group_collective_functions_support")
+      get_info("Device", :cl_bool, "generic_address_space_support")
+      get_info("Device", :cl_bool, "device_enqueue_support")
+      get_info("Device", :cl_bool, "pipe_support")
+
+      def numeric_version
+        ptr = MemoryPointer::new( :cl_version )
+        error = OpenCL.clGetDeviceInfo( self, NUMERIC_VERSION, 4, ptr, nil)
+        error_check(error)
+        return Version::from_int(ptr.read_cl_version)
+      end
+
+      def extensions_with_version
+        sz = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetDeviceInfo( self, EXTENSIONS_WITH_VERSION, 0, nil, sz)
+        error_check(error)
+        sz = sz.read_size_t
+        ptr = MemoryPointer::new( sz )
+        error = OpenCL.clGetDeviceInfo( self, EXTENSIONS_WITH_VERSION, sz, ptr, nil)
+        error_check(error)
+        nvsz = NameVersion.size
+        return (sz/nvsz).times.collect { |i| NameVersion::new(ptr + i*nvsz) }
+      end
+
+      def ils_with_version
+        sz = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetDeviceInfo( self, ILS_WITH_VERSION, 0, nil, sz)
+        error_check(error)
+        sz = sz.read_size_t
+        ptr = MemoryPointer::new( sz )
+        error = OpenCL.clGetDeviceInfo( self, ILS_WITH_VERSION, sz, ptr, nil)
+        error_check(error)
+        nvsz = NameVersion.size
+        return (sz/nvsz).times.collect { |i| NameVersion::new(ptr + i*nvsz) }
+      end
+
+      def built_in_kernels_with_version
+        sz = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS_WITH_VERSION, 0, nil, sz)
+        error_check(error)
+        sz = sz.read_size_t
+        ptr = MemoryPointer::new( sz )
+        error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS_WITH_VERSION, sz, ptr, nil)
+        error_check(error)
+        nvsz = NameVersion.size
+        return (sz/nvsz).times.collect { |i| NameVersion::new(ptr + i*nvsz) }
+      end
+
+      def opencl_c_all_versions
+        sz = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetDeviceInfo( self, OPENCL_C_ALL_VERSIONS, 0, nil, sz)
+        error_check(error)
+        sz = sz.read_size_t
+        ptr = MemoryPointer::new( sz )
+        error = OpenCL.clGetDeviceInfo( self, OPENCL_C_ALL_VERSIONS, sz, ptr, nil)
+        error_check(error)
+        nvsz = NameVersion.size
+        return (sz/nvsz).times.collect { |i| NameVersion::new(ptr + i*nvsz) }
+      end
+
+      def opencl_c_features
+        sz = MemoryPointer::new( :size_t )
+        error = OpenCL.clGetDeviceInfo( self, OPENCL_C_FEATURES, 0, nil, sz)
+        error_check(error)
+        sz = sz.read_size_t
+        ptr = MemoryPointer::new( sz )
+        error = OpenCL.clGetDeviceInfo( self, OPENCL_C_FEATURES, sz, ptr, nil)
+        error_check(error)
+        nvsz = NameVersion.size
+        return (sz/nvsz).times.collect { |i| NameVersion::new(ptr + i*nvsz) }
+      end
+    end
+
+    register_extension( :v11, OpenCL11, "platform.version_number >= 1.1" )
+    register_extension( :v12, OpenCL12, "platform.version_number >= 1.2" )
+    register_extension( :v20, OpenCL20, "platform.version_number >= 2.0" )
+    register_extension( :v21, OpenCL21, "platform.version_number >= 2.1" )
+    register_extension( :v30, OpenCL30, "platform.version_number >= 3.0" )
 
   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/Image.rb

@@ -13,11 +13,17 @@ module OpenCL
   # 
   # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image
   # * +:host_ptr+ - if provided, the Pointer (or convertible to Pointer using to_ptr) to the memory area to use
+  # * +:properties+ - if provided, an array of :cl_mem_properties (OpenCL 3.0)
   def self.create_image( context, format, desc, options = {} )
     flags = get_flags( options )
     host_ptr = options[:host_ptr]
     error = MemoryPointer::new( :cl_int )
-    img_ptr = clCreateImage( context, flags, format, desc, host_ptr, error )
+    if context.platform.version_number < 3.0 then
+      img_ptr = clCreateImage( context, flags, format, desc, host_ptr, error )
+    else
+      properties = get_mem_properties( options )
+      img_ptr = clCreateImageWithProperties( context, properties, flags, format, desc, host_ptr, error )
+    end
     error_check(error.read_cl_int)
     return Image::new(img_ptr, false)
   end

data/lib/opencl_ruby_ffi/Kernel.rb

@@ -29,9 +29,12 @@ module OpenCL
     sz = size
     sz = value.class.size if sz == nil
     val = value
-    if value.kind_of?(Mem) then
+    if value.kind_of?(Mem)
       val = MemoryPointer::new( Mem )
       val.write_pointer(value.to_ptr)
+    elsif value.kind_of?(Sampler)
+      val = MemoryPointer::new( Sampler )
+      val.write_pointer(value.to_ptr)
     end
     error = clSetKernelArg( kernel, index, sz, val )
     error_check(error)
@@ -113,58 +116,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 +202,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 +295,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)