opencl_ruby_ffi 1.3.5 → 1.3.10

data/lib/opencl_ruby_ffi/Event.rb

@@ -77,23 +77,30 @@ module OpenCL
 
     # Returns the CommandQueue associated with the Event, if it exists
     def 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
-      else
-        return 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
     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
+      @_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 +147,12 @@ module OpenCL
 
       # Returns the Context associated with the Event
       def context
-        ptr = MemoryPointer::new( Context )
-        error = OpenCL.clGetEventInfo(self, CONTEXT, Context.size, ptr, nil)
-        error_check(error)
-        return 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

@@ -18,6 +18,7 @@ module OpenCL
   # Returns the Kernel corresponding the the specified name in the given Program
   def self.create_kernel(program, name)
     error = MemoryPointer::new( :cl_int )
+    name = name.to_s
     kernel_ptr = clCreateKernel(program, name, error)
     error_check(error.read_cl_int)
     return Kernel::new( kernel_ptr, false )
@@ -63,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)
@@ -107,53 +113,63 @@ module OpenCL
 
         # Returns an AddressQualifier corresponding to the Arg
         def 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 ||= 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
-          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 ||= 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
-          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)
-          return 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
-          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 ||= 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
-          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)
-          return 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
@@ -174,27 +190,36 @@ 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
+      @_platform ||= self.context.platform
+    end
+
     # Returns the Context the Kernel is associated with
     def context
-      ptr = MemoryPointer::new( Context )
-      error = OpenCL.clGetKernelInfo(self, CONTEXT, Context.size, ptr, nil)
-      error_check(error)
-      return 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
-      ptr = MemoryPointer::new( Program )
-      error = OpenCL.clGetKernelInfo(self, PROGRAM, Program.size, ptr, nil)
-      error_check(error)
-      return 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)
@@ -267,14 +292,16 @@ module OpenCL
       ##
       # returns a String containing the attributes qualifier used at kernel definition
       def 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
-        return 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

@@ -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
-      ptr = MemoryPointer::new( Context )
-      error = OpenCL.clGetMemObjectInfo(self, CONTEXT, Context.size, ptr, nil)
-      error_check(error)
-      return 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 self.context.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,12 +129,18 @@ module OpenCL
     module OpenCL20
       extend InnerGenerator
 
-      get_info("Mem", :cl_bool, "uses_svm_pointer")
+      get_info("Mem", :cl_bool, "uses_svm_pointer", true)
+    end
+
+    module OpenCL30
+      extend InnerGenerator
 
+      get_info_array("Mem", :cl_mem_properties, "properties")
     end
 
     register_extension( :v11,  OpenCL11, "platform.version_number >= 1.1" )
     register_extension( :v20,  OpenCL20, "platform.version_number >= 2.0" )
+    register_extension( :v30,  OpenCL30, "platform.version_number >= 3.0" )
 
   end
 

data/lib/opencl_ruby_ffi/Pipe.rb

@@ -34,6 +34,14 @@ module OpenCL
     get_info("Pipe", :cl_uint, "packet_size")
     get_info("Pipe", :cl_uint, "max_packets")
 
+    module OpenCL30
+      extend InnerGenerator
+
+      get_info_array("Pipe", :cl_pipe_properties, "properties")
+    end
+
+    register_extension( :v30,  Pipe::OpenCL30, "platform.version_number >= 3.0" )
+
   end
 
 end

data/lib/opencl_ruby_ffi/Platform.rb

@@ -63,16 +63,18 @@ module OpenCL
 
   # Returns an Array of Platform containing the available OpenCL platforms
   def self.get_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)
-    return ptr2.get_array_of_pointer(0,ptr1.read_uint()).collect { |platform_ptr|
-      Platform::new(platform_ptr, false)
-    }
+      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
@@ -88,11 +90,11 @@ module OpenCL
       return "#<#{self.class.name}: #{self.name}>"
     end
 
-    get_info("Platform", :string, "profile")
-    get_info("Platform", :string, "version")
-    get_info("Platform", :string, "name")
+    get_info("Platform", :string, "profile", true)
+    get_info("Platform", :string, "version", true)
+    get_info("Platform", :string, "name", true)
     alias to_s name
-    get_info("Platform", :string, "vendor")
+    get_info("Platform", :string, "vendor", true)
 
     # Returns an Array of string corresponding to the Platform extensions
     def extensions
@@ -175,12 +177,37 @@ module OpenCL
     module OpenCL21
       extend InnerGenerator
 
-      get_info("Platform", :cl_ulong, "host_timer_resolution")
+      get_info("Platform", :cl_ulong, "host_timer_resolution", true)
+
+    end
+
+    module OpenCL30
+      extend InnerGenerator
+
+      def numeric_version
+        ptr = MemoryPointer::new( :cl_version )
+        error = OpenCL.clGetPlatformInfo( 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.clGetPlatformInfo( self, EXTENSIONS_WITH_VERSION, 0, nil, sz)
+        error_check(error)
+        sz = sz.read_size_t
+        ptr = MemoryPointer::new( sz )
+        error = OpenCL.clGetPlatformInfo( 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
 
     end
 
     register_extension( :v12, OpenCL12, "version_number >= 1.2" )
     register_extension( :v21, OpenCL21, "version_number >= 2.1" )
+    register_extension( :v30, OpenCL30, "version_number >= 3.0" )
 
   end
 

data/lib/opencl_ruby_ffi/Program.rb

@@ -15,12 +15,20 @@ module OpenCL
   # * +:options+ - a String containing the options to use for the build
   # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
   def self.build_program(program, options = {}, &block)
-    @@callbacks.push( block ) if 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
     num_devices, devices_p = get_device_list( options )
     opt = ""
     opt = options[:options] if options[:options]
     options_p = MemoryPointer.from_string(opt)
-    error = clBuildProgram(program, num_devices, devices_p, options_p, block, options[:user_data] )
+    error = clBuildProgram(program, num_devices, devices_p, options_p, wrapper_block, options[:user_data] )
     error_check(error)
     return program
   end
@@ -40,7 +48,15 @@ module OpenCL
   # * +:options+ - a String containing the options to use for the build
   # * +:user_data+ - a Pointer (or convertible to Pointer using to_ptr) to the memory area to pass to the callback
   def self.link_program(context, input_programs, options = {}, &block)
-    @@callbacks.push( block ) if 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
     num_devices, devices_p = get_device_list( options )
     opt = ""
     opt = options[:options] if options[:options]
@@ -50,7 +66,7 @@ module OpenCL
     programs_p = MemoryPointer::new( Program, num_programs )
     programs_p.write_array_of_pointer(programs)
     error = MemoryPointer::new( :cl_int )
-    prog = clLinkProgram( context, num_devices, devices_p, options_p, num_programs, programs_p, block, options[:user_data], error)
+    prog = clLinkProgram( context, num_devices, devices_p, options_p, num_programs, programs_p, wrapper_block, options[:user_data], error)
     error_check(error.read_cl_int)
     return Program::new( prog, false )
   end
@@ -70,7 +86,15 @@ module OpenCL
   # * +:options+ - a String containing the options to use for the compilation
   # * +:input_headers+ - a Hash containing pairs of : String: header_include_name => Program: header
   def self.compile_program(program, options = {}, &block)
-    @@callbacks.push( block ) if 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
     num_devices, devices_p = get_device_list( options )
     opt = ""
     opt = options[:options] if options[:options]
@@ -80,7 +104,7 @@ module OpenCL
     header_include_names = nil
     num_headers = 0
     num_headers = headers.length if headers
-    if num_headers then
+    if num_headers > 0 then
       headers_p = MemoryPointer::new( Program, num_headers )
       header_include_names = MemoryPointer::new( :pointer, num_headers )
       indx = 0
@@ -90,7 +114,7 @@ module OpenCL
         indx = indx + 1
       }
     end
-    error = clCompileProgram(program, num_devices, devices_p, options_p, num_headers, headers_p, header_include_names, block, options[:user_data] )
+    error = clCompileProgram(program, num_devices, devices_p, options_p, num_headers, headers_p, header_include_names, wrapper_block, options[:user_data] )
     error_check(error)
     return program
   end
@@ -125,10 +149,10 @@ module OpenCL
   # * +device_list+ - an Array of Device to create the program for. Can throw an Error::INVALID_VALUE if the number of supplied devices is different from the number of supplied binaries.
   # * +binaries+ - Array of binaries 
   def self.create_program_with_binary(context, device_list, binaries)
-    bins = [binaries].flatten
-    num_devices = bins.length
+    binaries = [binaries].flatten
+    num_devices = binaries.length
     devices = [device_list].flatten
-    error_check(INVALID_VALUE) if devices.length != bins.length
+    error_check(INVALID_VALUE) if devices.length != binaries.length
     devices_p = MemoryPointer::new( Device, num_devices )
     lengths = MemoryPointer::new( :size_t, num_devices )
     binaries_p = MemoryPointer::new( :pointer, num_devices )
@@ -215,8 +239,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_program_release_callback( program, options = {}, &block )
-    @@callbacks.push( block ) if block
-    error = clSetProgramReleaseCallback( program, 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 = clSetProgramReleaseCallback( program, wrapper_block, options[:user_data] )
     error_check(error)
     return program
   end
@@ -248,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
@@ -270,26 +306,35 @@ module OpenCL
       end
     end
 
+    # Returns the Platform associated with the Program
+    def platform
+      @_platform ||= self.context.platform
+    end
+
     # Returns the Context the Program is associated to
     def context
-      ptr = MemoryPointer::new( Context )
-      error = OpenCL.clGetProgramInfo(self, CONTEXT, Context.size, ptr, nil)
-      error_check(error)
-      return Context::new( ptr.read_pointer )
+      @_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")
+    get_info("Program", :cl_uint, "num_devices", true)
     get_info("Program", :cl_uint, "reference_count")
 
     # Returns the Array of Device the Program is associated with
     def devices
-      n = self.num_devices
-      ptr2 = MemoryPointer::new( Device, n )
-      error = OpenCL.clGetProgramInfo(self, DEVICES, Device.size*n, ptr2, nil)
-      error_check(error)
-      return ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
-        Device::new(device_ptr)
-      }
+      @_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")
@@ -462,7 +507,7 @@ module OpenCL
         il_size = MemoryPointer::new( :size_t )
         error = OpenCL.clGetProgramInfo(self, IL, 0, nil, il_size)
         error_check(error)
-        return nil if il_size == 0
+        return nil if il_size.read_size_t == 0
         length = il_size.read_size_t
         il_p = MemoryPointer::new( length )
         error = OpenCL.clGetProgramInfo(self, IL, length, il_p, nil)