opencl_ruby_ffi 0.3 → 0.4

data/lib/opencl_ruby_ffi/Event.rb

@@ -1,5 +1,16 @@
 module OpenCL
 
+  # Waits for the command identified by Event objects to complete
+  #
+  # ==== Attributes
+  #
+  # * +event_list+ - a single or an Array of Event to wait upon before returning
+  def self.wait_for_events(event_list)
+    num_events, events = OpenCL.get_event_wait_list( {:event_wait_list => event_list } )
+    error = OpenCL.clWaitForEvents(num_events, events)
+    OpenCL.error_check(error)
+    return nil
+  end
   
   # Attaches a callback to event that will be called on the given transition
   #
@@ -58,7 +69,7 @@ module OpenCL
 
     # Returns the CommandQueue associated with the Event, if it exists
     def command_queue
-      ptr = FFI::MemoryPointer.new( CommandQueue )
+      ptr = FFI::MemoryPointer::new( CommandQueue )
       error = OpenCL.clGetEventInfo(self, Event::COMMAND_QUEUE, CommandQueue.size, ptr, nil)
       OpenCL.error_check(error)
       pt = ptr.read_pointer
@@ -71,7 +82,7 @@ module OpenCL
 
     # Returns the Context associated with the Event
     def context
-      ptr = FFI::MemoryPointer.new( Context )
+      ptr = FFI::MemoryPointer::new( Context )
       error = OpenCL.clGetEventInfo(self, Event::CONTEXT, Context.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Context::new( ptr.read_pointer )
@@ -82,7 +93,7 @@ module OpenCL
 
     # Returns a CommandExecutionStatus corresponding to the status of the command associtated with the Event
     def command_execution_status
-      ptr = FFI::MemoryPointer.new( :cl_int )
+      ptr = FFI::MemoryPointer::new( :cl_int )
       error = OpenCL.clGetEventInfo(self, OpenCL::Event::COMMAND_EXECUTION_STATUS, ptr.size, ptr, nil )
       OpenCL.error_check(error)
       return OpenCL::CommandExecutionStatus::new( ptr.read_cl_int )
@@ -95,7 +106,7 @@ module OpenCL
 
     # Returns the date the command corresponding to Event was queued
     def profiling_command_queued
-       ptr = FFI::MemoryPointer.new( :cl_ulong )
+       ptr = FFI::MemoryPointer::new( :cl_ulong )
        error = OpenCL.clGetEventProfilingInfo(self, OpenCL::PROFILING_COMMAND_QUEUED, ptr.size, ptr, nil )
        OpenCL.error_check(error)
        return ptr.read_cl_ulong
@@ -103,7 +114,7 @@ module OpenCL
 
     # Returns the date the command corresponding to Event was submited
     def profiling_command_submit
-       ptr = FFI::MemoryPointer.new( :cl_ulong )
+       ptr = FFI::MemoryPointer::new( :cl_ulong )
        error = OpenCL.clGetEventProfilingInfo(self, OpenCL::PROFILING_COMMAND_SUBMIT, ptr.size, ptr, nil )
        OpenCL.error_check(error)
        return ptr.read_cl_ulong
@@ -111,7 +122,7 @@ module OpenCL
 
     # Returns the date the command corresponding to Event started
     def profiling_command_start
-       ptr = FFI::MemoryPointer.new( :cl_ulong )
+       ptr = FFI::MemoryPointer::new( :cl_ulong )
        error = OpenCL.clGetEventProfilingInfo(self, OpenCL::PROFILING_COMMAND_START, ptr.size, ptr, nil )
        OpenCL.error_check(error)
        return ptr.read_cl_ulong
@@ -119,7 +130,7 @@ module OpenCL
 
     # Returns the date the command corresponding to Event ended
     def profiling_command_end
-       ptr = FFI::MemoryPointer.new( :cl_ulong )
+       ptr = FFI::MemoryPointer::new( :cl_ulong )
        error = OpenCL.clGetEventProfilingInfo(self, OpenCL::PROFILING_COMMAND_END, ptr.size, ptr, nil )
        OpenCL.error_check(error)
        return ptr.read_cl_ulong

data/lib/opencl_ruby_ffi/Image.rb

@@ -15,7 +15,7 @@ module OpenCL
   def self.create_image( context, format, desc, options = {} )
     flags = OpenCL.get_flags( options )
     host_ptr = options[:host_ptr]
-    error = FFI::MemoryPointer.new( :cl_int )
+    error = FFI::MemoryPointer::new( :cl_int )
     img_ptr = OpenCL.clCreateImage( context, flags, format, desc, host_ptr, error )
     OpenCL.error_check(error.read_cl_int)
     return Image::new(img_ptr, false)
@@ -64,7 +64,7 @@ module OpenCL
     end
     flags = OpenCL.get_flags( options )
     host_ptr = options[:host_ptr]
-    error = FFI::MemoryPointer.new( :cl_int )
+    error = FFI::MemoryPointer::new( :cl_int )
     img_ptr = OpenCL.clCreateImage2D( context, flags, format, width, heigh, row_pitch, host_ptr, error )
     OpenCL.error_check(error.read_cl_int)
     return Image::new(img_ptr, false)
@@ -95,7 +95,7 @@ module OpenCL
     end
     flags = OpenCL.get_flags( options )
     host_ptr = options[:host_ptr]
-    error = FFI::MemoryPointer.new( :cl_int )
+    error = FFI::MemoryPointer::new( :cl_int )
     img_ptr = OpenCL.clCreateImage3D( context, fs, format, width, heigh, depth, row_pitch, slice_pitch, d, error )
     OpenCL.error_check(error.read_cl_int)
     return Image::new(img_ptr, false)
@@ -114,7 +114,7 @@ module OpenCL
   # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Image (default OpenCL::Mem::READ_WRITE)
   def self.create_from_GL_render_buffer( context, renderbuffer, options = {} )
     flags = OpenCL.get_flags( options )
-    error = FFI::MemoryPointer.new( :cl_int )
+    error = FFI::MemoryPointer::new( :cl_int )
     img = OpenCL.clCreateFromGLRenderBuffer( context, flags, renderbuffer, error )
     OpenCL.error_check(error.read_cl_int)
     return Image::new( img, false )
@@ -140,7 +140,7 @@ module OpenCL
     flags = OpenCL.get_flags( options )
     miplevel = 0
     miplevel =  options[:miplevel] if options[:miplevel]
-    error = FFI::MemoryPointer.new( :cl_int )
+    error = FFI::MemoryPointer::new( :cl_int )
     img = OpenCL.clCreateFromGLTexture( context, flags, texture_target, miplevel, texture, error )
     OpenCL.error_check(error.read_cl_int)
     return Image::new( img, false )
@@ -165,7 +165,7 @@ module OpenCL
     flags = OpenCL.get_flags( options )
     miplevel = 0
     miplevel =  options[:miplevel] if options[:miplevel]
-    error = FFI::MemoryPointer.new( :cl_int )
+    error = FFI::MemoryPointer::new( :cl_int )
     img = OpenCL.clCreateFromGLTexture2D( context, flags, texture_target, miplevel, texture, error )
     OpenCL.error_check(error.read_cl_int)
     return Image::new( img, false )
@@ -190,7 +190,7 @@ module OpenCL
     flags = OpenCL.get_flags( options )
     miplevel = 0
     miplevel =  options[:miplevel] if options[:miplevel]
-    error = FFI::MemoryPointer.new( :cl_int )
+    error = FFI::MemoryPointer::new( :cl_int )
     img = OpenCL.clCreateFromGLTexture3D( context, flags, texture_target, miplevel, texture, error )
     OpenCL.error_check(error.read_cl_int)
     return Image::new( img, false )
@@ -249,7 +249,7 @@ module OpenCL
 
     # Returns the ImageFormat corresponding to the image
     def format
-      image_format = FFI::MemoryPointer.new( ImageFormat )
+      image_format = FFI::MemoryPointer::new( ImageFormat )
       error = OpenCL.clGetImageInfo( self, OpenCL::Image::FORMAT, image_format.size, image_format, nil)
       OpenCL.error_check(error)
       return OpenCL::ImageFormat::from_pointer( image_format )
@@ -257,7 +257,7 @@ module OpenCL
 
     # Returns the associated Buffer if any, nil otherwise
     def buffer
-      ptr = FFI::MemoryPointer.new( OpenCL::Buffer )
+      ptr = FFI::MemoryPointer::new( OpenCL::Buffer )
       error = OpenCL.clGetImageInfo(self,  OpenCL::Image::BUFFER, OpenCL::Buffer.size, ptr, nil)
       OpenCL.error_check(error)
       return nil if ptr.null?

data/lib/opencl_ruby_ffi/Kernel.rb

@@ -2,21 +2,21 @@ module OpenCL
 
   # Creates an Array of Kernel corresponding to the kernels defined inside the Program
   def self.create_kernels_in_program( program )
-    num_ptr = FFI::MemoryPointer.new( :cl_uint )
+    num_ptr = FFI::MemoryPointer::new( :cl_uint )
     error = OpenCL. clCreateKernelsInProgram( program, 0, nil, num_ptr )
     OpenCL.error_check(error)
     num_kernels = num_ptr.read_cl_uint
-    kernels_ptr = FFI::MemoryPointer.new( OpenCL::Kernel, num_kernels )
+    kernels_ptr = FFI::MemoryPointer::new( OpenCL::Kernel, num_kernels )
     error = OpenCL. clCreateKernelsInProgram( program, num_kernels, kernels_ptr, 0 )
     OpenCL.error_check(error)
     return kernels_ptr.get_array_of_pointer(0, num_kernels).collect { |kernel_ptr|
-      OpenCL::Kernel.new(kernel_ptr, false)
+      OpenCL::Kernel::new(kernel_ptr, false)
     }
   end
 
   # Returns the Kernel corresponding the the specified name in the given Program
   def self.create_kernel(program, name)
-    pointer_err = FFI::MemoryPointer.new( :cl_int )
+    pointer_err = FFI::MemoryPointer::new( :cl_int )
     kernel_ptr = OpenCL.clCreateKernel(program, name, pointer_err)
     OpenCL.error_check(pointer_err.read_cl_int)
     return OpenCL::Kernel::new( kernel_ptr, false )
@@ -28,7 +28,7 @@ module OpenCL
     sz = value.class.size if sz == nil
     val = value
     if value.kind_of?(OpenCL::Mem) then
-      val = FFI::MemoryPointer.new( OpenCL::Mem )
+      val = FFI::MemoryPointer::new( OpenCL::Mem )
       val.write_pointer(value.to_ptr)
     end
     error = OpenCL.clSetKernelArg( kernel, index, sz, val )
@@ -54,7 +54,7 @@ module OpenCL
       # Returns an AddressQualifier corresponding to the Arg
       def address_qualifier
         OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
-        ptr = FFI::MemoryPointer.new( :cl_kernel_arg_address_qualifier )
+        ptr = FFI::MemoryPointer::new( :cl_kernel_arg_address_qualifier )
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::ADDRESS_QUALIFIER, ptr.size, ptr, nil)
         OpenCL.error_check(error)
         return OpenCL::Kernel::Arg::AddressQualifier::new( ptr.read_cl_kernel_arg_address_qualifier )
@@ -63,7 +63,7 @@ module OpenCL
       # Returns an AccessQualifier corresponding to the Arg
       def access_qualifier
         OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
-        ptr = FFI::MemoryPointer.new( :cl_kernel_arg_access_qualifier )
+        ptr = FFI::MemoryPointer::new( :cl_kernel_arg_access_qualifier )
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::ACCESS_QUALIFIER, ptr.size, ptr, nil)
         OpenCL.error_check(error)
         return OpenCL::Kernel::Arg::AccessQualifier::new( ptr.read_cl_kernel_arg_access_qualifier )
@@ -72,7 +72,7 @@ module OpenCL
       # Returns a TypeQualifier corresponding to the Arg
       def type_qualifier
         OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
-        ptr = FFI::MemoryPointer.new( :cl_kernel_arg_type_qualifier )
+        ptr = FFI::MemoryPointer::new( :cl_kernel_arg_type_qualifier )
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::TYPE_QUALIFIER, ptr.size, ptr, nil)
         OpenCL.error_check(error)
         return OpenCL::Kernel::Arg::TypeQualifier::new( ptr.read_cl_kernel_arg_type_qualifier )
@@ -81,10 +81,10 @@ module OpenCL
       # Returns a String corresponding to the Arg type name
       def type_name
         OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
-        ptr1 = FFI::MemoryPointer.new( :size_t, 1)
+        ptr1 = FFI::MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::TYPE_NAME, 0, nil, ptr1)
         OpenCL.error_check(error)
-        ptr2 = FFI::MemoryPointer.new( ptr1.read_size_t )
+        ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::TYPE_NAME, ptr1.read_size_t, ptr2, nil)
         OpenCL.error_check(error)
         return ptr2.read_string
@@ -93,10 +93,10 @@ module OpenCL
       # Returns a String corresponding to the Arg name
       def name
         OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
-        ptr1 = FFI::MemoryPointer.new( :size_t, 1)
+        ptr1 = FFI::MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::NAME, 0, nil, ptr1)
         OpenCL.error_check(error)
-        ptr2 = FFI::MemoryPointer.new( ptr1.read_size_t )
+        ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::NAME, ptr1.read_size_t, ptr2, nil)
         OpenCL.error_check(error)
         return ptr2.read_string
@@ -143,7 +143,7 @@ module OpenCL
 
     # Returns the Context the Kernel is associated with
     def context
-      ptr = FFI::MemoryPointer.new( Context )
+      ptr = FFI::MemoryPointer::new( Context )
       error = OpenCL.clGetKernelInfo(self, Kernel::CONTEXT, Context.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Context::new( ptr.read_pointer )
@@ -151,7 +151,7 @@ module OpenCL
 
     # Returns the Program the Kernel was created from
     def program
-      ptr = FFI::MemoryPointer.new( Program )
+      ptr = FFI::MemoryPointer::new( Program )
       error = OpenCL.clGetKernelInfo(self, Kernel::PROGRAM, Program.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Program::new(ptr.read_pointer)

data/lib/opencl_ruby_ffi/Mem.rb

@@ -23,7 +23,7 @@ module OpenCL
 
     # Returns the Context associated to the Mem
     def context
-      ptr = FFI::MemoryPointer.new( Context )
+      ptr = FFI::MemoryPointer::new( Context )
       error = OpenCL.clGetMemObjectInfo(self, Mem::CONTEXT, Context.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Context::new( ptr.read_pointer )
@@ -36,7 +36,7 @@ module OpenCL
 
     # Returns the Buffer this Buffer was created from using create_sub_buffer
     def associated_memobject
-      ptr = FFI::MemoryPointer.new( Mem )
+      ptr = FFI::MemoryPointer::new( Mem )
       error = OpenCL.clGetMemObjectInfo(self, Mem::ASSOCIATED_MEMOBJECT, Mem.size, ptr, nil)
       OpenCL.error_check(error)
       return nil if ptr.read_pointer.null?
@@ -96,7 +96,7 @@ module OpenCL
 
     # Returns the texture_target argument specified in create_from_GL_texture for Mem
     def GL_texture_target
-      param_value = MemoryPointer.new( :cl_GLenum )
+      param_value = MemoryPointer::new( :cl_GLenum )
       error = OpenCL.clGetGLTextureInfo( self, OpenCL::GL_TEXTURE_TARGET, param_value.size, param_value, nil )
       OpenCL.error_check(error)
       return param_value.read_cl_GLenum
@@ -104,7 +104,7 @@ module OpenCL
 
     # Returns the miplevel argument specified in create_from_GL_texture for Mem
     def GL_mimap_level
-      param_value = MemoryPointer.new( :cl_GLint )
+      param_value = MemoryPointer::new( :cl_GLint )
       error = OpenCL.clGetGLTextureInfo( self, OpenCL::GL_MIPMAP_LEVEL, param_value.size, param_value, nil )
       OpenCL.error_check(error)
       return param_value.read_cl_GLint
@@ -112,15 +112,15 @@ module OpenCL
 
     # Returns the type of the GL object associated with Mem
     def GL_object_type
-      param_value = MemoryPointer.new( :cl_gl_object_type )
+      param_value = MemoryPointer::new( :cl_gl_object_type )
       error = OpenCL.clGetGLObjectInfo( self, param_value, nil )
       OpenCL.error_check(error)
-      return OpenCL::GLObjectType(param_value.read_cl_gl_object_type)
+      return OpenCL::GLObjectType::new(param_value.read_cl_gl_object_type)
     end
 
     # Returns the name of the GL object associated with Mem
     def GL_object_name
-      param_value = MemoryPointer.new( :cl_GLuint )
+      param_value = MemoryPointer::new( :cl_GLuint )
       error = OpenCL.clGetGLObjectInfo( self, nil, param_value )
       OpenCL.error_check(error)
       return param_value.read_cl_GLuint

data/lib/opencl_ruby_ffi/Platform.rb

@@ -1,5 +1,24 @@
 module OpenCL
 
+  # Unloads a Platform compiler
+  #
+  # ==== Attributes
+  #
+  # * +platform+ - the Platform to have it's compiler unloaded
+  def self.unload_platform_compiler(platform)
+    OpenCL.error_check(OpenCL::INVALID_OPERATION) if self.version_number < 1.2
+    error = OpenCL.clUnloadPlatformCompiler( platform )
+    OpenCL.error_check(error)
+    return platform
+  end
+
+  # Unloads the compiler
+  def self.unload_compiler
+    error = OpenCL.clUnloadCompiler()
+    OpenCL.error_check(error)
+    return nil
+  end
+
   # Returns an FFI::Function corresponding to an extension function
   #
   # ==== Attributes
@@ -15,20 +34,6 @@ module OpenCL
     return FFI::Function::new(return_type, param_types, ptr, options)
   end
 
-  # Returns an Array of Platforms containing the available OpenCL platforms
-  def self.get_platforms
-    ptr1 = FFI::MemoryPointer.new(:cl_uint , 1)
-    
-    error = OpenCL::clGetPlatformIDs(0, nil, ptr1)
-    OpenCL.error_check(error)
-    ptr2 = FFI::MemoryPointer.new(:pointer, ptr1.read_uint)
-    error = OpenCL::clGetPlatformIDs(ptr1.read_uint(), ptr2, nil)
-    OpenCL.error_check(error)
-    return ptr2.get_array_of_pointer(0,ptr1.read_uint()).collect { |platform_ptr|
-      OpenCL::Platform.new(platform_ptr)
-    }
-  end
-
   # Returns an FFI::Function corresponding to an extension function for the Platform
   #
   # ==== Attributes
@@ -46,6 +51,20 @@ module OpenCL
     return FFI::Function::new(return_type, param_types, ptr, options)
   end
 
+  # Returns an Array of Platforms containing the available OpenCL platforms
+  def self.get_platforms
+    ptr1 = FFI::MemoryPointer::new(:cl_uint , 1)
+    
+    error = OpenCL::clGetPlatformIDs(0, nil, ptr1)
+    OpenCL.error_check(error)
+    ptr2 = FFI::MemoryPointer::new(:pointer, ptr1.read_uint)
+    error = OpenCL::clGetPlatformIDs(ptr1.read_uint(), ptr2, nil)
+    OpenCL.error_check(error)
+    return ptr2.get_array_of_pointer(0,ptr1.read_uint()).collect { |platform_ptr|
+      OpenCL::Platform::new(platform_ptr, false)
+    }
+  end
+
 
   # Maps the cl_platform_id object of OpenCL
   class Platform
@@ -56,14 +75,14 @@ module OpenCL
     # Returns an Array of Device corresponding to the available devices on the Platform
     # The type of the desired devices can be specified
     def devices(type = OpenCL::Device::Type::ALL)
-      ptr1 = FFI::MemoryPointer.new(:cl_uint , 1)
+      ptr1 = FFI::MemoryPointer::new(:cl_uint , 1)
       error = OpenCL::clGetDeviceIDs(self, type, 0, nil, ptr1)
       OpenCL.error_check(error)
-      ptr2 = FFI::MemoryPointer.new(:pointer, ptr1.read_uint)
+      ptr2 = FFI::MemoryPointer::new(:pointer, ptr1.read_uint)
       error = OpenCL::clGetDeviceIDs(self, type, ptr1.read_uint(), ptr2, nil)
       OpenCL.error_check(error)
       return ptr2.get_array_of_pointer(0, ptr1.read_uint()).collect { |device_ptr|
-        OpenCL::Device.new(device_ptr)
+        OpenCL::Device::new(device_ptr, false)
       }
     end
 
@@ -74,6 +93,11 @@ module OpenCL
       return n.first.first.to_f
     end
 
+    # Unloads the Platform compiler
+    def unload_compiler
+      return OpenCL.unload_platform_compiler(self)
+    end
+
     # Returns an FFI::Function corresponding to an extension function for a Platform
     #
     # ==== Attributes