opencl_ruby_ffi 0.95 → 0.96

data/lib/opencl_ruby_ffi.rb

@@ -12,6 +12,8 @@ require "opencl_ruby_ffi/Event.rb"
 require "opencl_ruby_ffi/Kernel.rb"
 require "opencl_ruby_ffi/Image.rb"
 require "opencl_ruby_ffi/Sampler.rb"
+require "opencl_ruby_ffi/Pipe.rb"
+require "opencl_ruby_ffi/SVM.rb"
 
 require "narray_ffi"
 

data/lib/opencl_ruby_ffi/Buffer.rb

@@ -15,7 +15,7 @@ module OpenCL
   def self.create_buffer( context, size, options = {} )
     flags = OpenCL.get_flags( options )
     host_ptr = options[:host_ptr]
-    error = FFI::MemoryPointer.new( :cl_int )
+    error = FFI::MemoryPointer::new( :cl_int )
     buff = OpenCL.clCreateBuffer(context, flags, size, host_ptr, error)
     OpenCL.error_check(error.read_cl_int)
     return OpenCL::Buffer::new( buff, false )

data/lib/opencl_ruby_ffi/CommandQueue.rb

@@ -33,10 +33,36 @@ module OpenCL
   # ==== Options
   # 
   # * +:properties+ - a single or an Array of :cl_command_queue_properties
+  # * +:size+ - the size of the command queue ( if ON_DEVICE is specified in the properties ) 2.0+ only
   def self.create_command_queue( context, device, options = {} )
     properties = OpenCL.get_command_queue_properties( options )
+    size = options[:size]
     error = FFI::MemoryPointer::new( :cl_int )
-    cmd = OpenCL.clCreateCommandQueue( context, device, properties, error )
+    if context.platform.version_number < 2.0 then
+      cmd = OpenCL.clCreateCommandQueue( context, device, properties, error )
+    else
+      props = nil
+      if properties.to_i != 0 or size then
+        props_size = 0
+        props_size += 2 if properties.to_i != 0
+        props_size += 2 if size
+        props_size += 1 if props_size > 0
+        props = FFI::MemoryPointer::new( :cl_queue_properties, props_size )
+        i=0
+        if properties.to_i != 0 then
+          props[i].write_cl_queue_properties( OpenCL::Queue::PROPERTIES )
+          props[i+1].write_cl_queue_properties( properties.to_i )
+          i += 2
+        end
+        if size then
+          props[i].write_cl_queue_properties( OpenCL::Queue::SIZE )
+          props[i+1].write_cl_queue_properties( size )
+          i += 2
+        end
+        props[i].write_cl_queue_properties( 0 )
+      end
+      cmd = OpenCL.clCreateCommandQueueWithProperties( context, device, props, error )
+    end
     OpenCL.error_check(error.read_cl_int)
     return OpenCL::CommandQueue::new(cmd, false)
   end
@@ -111,13 +137,13 @@ module OpenCL
     image_slice_pitch = FFI::MemoryPointer::new( :size_t )
     event = FFI::MemoryPointer::new( OpenCL::Event )
     error = FFI::MemoryPointer::new( :cl_int )
-    OpenCL.clEnqueueMapImage( command_queue, image, blocking, flags, origin, region, image_row_pitch, image_slice_pitch, num_events, events, event, error )
+    ptr = OpenCL.clEnqueueMapImage( command_queue, image, blocking, flags, origin, region, image_row_pitch, image_slice_pitch, num_events, events, event, error )
     OpenCL.error_check( error.read_cl_int )
     ev = OpenCL::Event::new( event.read_ptr, false )
     return [ev, ptr, image_row_pitch.read_size_t, image_slice_pitch.read_size_t]
   end
 
-  # Enqueues a command to map an Image into host memory
+  # Enqueues a command to map aa Buffer into host memory
   #
   # ==== Attributes
   # 
@@ -151,7 +177,7 @@ module OpenCL
     num_events, events = OpenCL.get_event_wait_list( options )
     event = FFI::MemoryPointer::new( OpenCL::Event )
     error = FFI::MemoryPointer::new( :cl_int )
-    ptr = OpenCL.clEnqueueMapBuffer( command_queue, buffer, blocking, flags, offset, size, num_events, events, error )
+    ptr = OpenCL.clEnqueueMapBuffer( command_queue, buffer, blocking, flags, offset, size, num_events, events, event, error )
     OpenCL.error_check( error.read_cl_int )
     ev = OpenCL::Event::new( event.read_ptr, false )
     return [ev, ptr]
@@ -1030,6 +1056,11 @@ module OpenCL
     # Returns the reference count of the CommandQueue
     eval OpenCL.get_info("CommandQueue", :cl_uint, "REFERENCE_COUNT")
 
+    ##
+    # :method: size
+    # Returns the currently specified size for the command queue (2.0 and for device queue only)
+    eval OpenCL.get_info("CommandQueue", :cl_uint, "SIZE")
+
     ##
     # :method: properties
     # Returns the :cl_command_queue_properties used to create the CommandQueue
@@ -1477,7 +1508,7 @@ module OpenCL
       return OpenCL.enqueue_release_GL_object( self, mem_objects, options )
     end
 
-    # Enqueues a command to map an Image into host memory using the CommandQueue
+    # Enqueues a command to map a Buffer into host memory using the CommandQueue
     #
     # ==== Attributes
     # 
@@ -1597,6 +1628,108 @@ module OpenCL
       return OpenCL.flush( self )
     end
 
+    # Enqueues a command to copy from or to an SVMPointer using the CommandQueue
+    #
+    # ==== Attributes
+    # 
+    # * +dst_ptr+ - the Pointer (or convertible to Pointer using to_ptr) or SVMPointer to be written to
+    # * +src_ptr+ - the Pointer (or convertible to Pointer using to_ptr) or SVMPointer to be read from
+    # * +size+ - the size of data to copy
+    # * +options+ - a hash containing named options
+    #
+    # ==== Options
+    #
+    # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
+    # * +:blocking_copy+ - if provided indicates if the command blocks until the copy finishes
+    # * +:blocking+ - if provided indicates if the command blocks until the copy finishes
+    #
+    # ==== Returns
+    #
+    # the Event associated with the command
+    def enqueue_svm_memcpy( dst_ptr, src_ptr, size, options = {})
+      return OpenCL.enqueue_svm_memcpy(self, dst_ptr, src_ptr, size, options)
+    end
+
+    # Enqueues a command that frees SVMPointers (or Pointers using a callback) using the CommandQueue
+    #
+    # ==== Attributes
+    # 
+    # * +svm_pointer+ - a single or an Array of SVMPointer (or Pointer)
+    # * +options+ - a hash containing named options
+    # * +block+ - if provided, a callback invoked to free the pointers. Signature of the callback is { |CommandQueue, num_pointers, FFI::Pointer to an array of num_pointers Pointers, FFI::Pointer to user_data| ... }
+    #
+    # ==== Options
+    #
+    # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
+    # * +:user_data+ - if provided, a Pointer (or convertible to using to_ptr) that will be passed to the callback
+    #
+    # ==== Returns
+    #
+    # the Event associated with the command
+    def enqueue_svm_free(svm_pointers, options = {}, &block)
+      return OpenCL.enqueue_svm_free(self, svm_pointers, options, &block)
+    end
+
+    # Enqueues a command to fill a an SVM memory area using the CommandQueue
+    #
+    # ==== Attributes
+    #
+    # * +svm_ptr+ - the SVMPointer to the area to fill
+    # * +pattern+ - the Pointer (or convertible to Pointer using to_ptr) to the memory area where the pattern is stored
+    # * +size+ - the size of the area to fill
+    #
+    # ==== Options
+    #
+    # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
+    # * +:pattern_size+ - if provided indicates the size of the pattern, else the maximum pattern data is used
+    #
+    # ==== Returns
+    #
+    # the Event associated with the command
+    def enqueue_svm_fill(command_queue, svm_ptr, pattern, size, options = {})
+      return OpenCL.enqueue_svm_fill(self, svm_ptr, pattern, size, options)
+    end
+
+    # Enqueues a command to map an Image into host memory using the CommandQueue
+    #
+    # ==== Attributes
+    # 
+    # * +svm_ptr+ - the SVMPointer to the area to map
+    # * +size+ - the size of the region to map
+    # * +map_flags+ - a single or an Array of :cl_map_flags flags
+    # * +options+ - a hash containing named options
+    #
+    # ==== Options
+    #
+    # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
+    # * +:blocking_map+ - if provided indicates if the command blocks until the region is mapped
+    # * +:blocking+ - if provided indicates if the command blocks until the region is mapped
+    #
+    # ==== Returns
+    #
+    # the Event associated with the command
+    def enqueue_svm_map( svm_ptr, size, map_flags, options = {} )
+      return OpenCL.enqueue_svm_map( self, svm_ptr, size, map_flags, options )
+    end
+  
+    # Enqueues a command to unmap a previously mapped SVM memory area using the CommandQueue
+    #
+    # ==== Attributes
+    # 
+    # * +svm_ptr+ - the SVMPointer of the area to be unmapped
+    # * +options+ - a hash containing named options
+    #
+    # ==== Options
+    #
+    # * +:event_wait_list+ - if provided, a list of Event to wait upon before executing the command
+    #
+    # ==== Returns
+    #
+    # the Event associated with the command
+    def enqueue_svm_unmap( svm_ptr, options = {} )
+      return OpenCL.enqueue_svm_unmap( self, svm_ptr, options )
+    end
+
   end
 
 end

data/lib/opencl_ruby_ffi/Context.rb

@@ -129,6 +129,7 @@ module OpenCL
     # ==== Options
     # 
     # * +:properties+ - a single or an Array of :cl_command_queue_properties
+    # * +:size+ - the size of the command queue ( if ON_DEVICE is specified in the properties ) 2.0+ only
     def create_command_queue( device, options = {} )
       return OpenCL.create_command_queue( self, device, options )
     end
@@ -350,14 +351,32 @@ module OpenCL
 
     # Creates a Sampler in the Context
     #
+    # ==== Options
+    #
+    # * +:normalized_coords+ - a :cl_bool specifying if the image coordinates are normalized
+    # * +:addressing_mode+ - a :cl_addressing_mode specifying how out-of-range image coordinates are handled when reading from an image
+    # * +:filter_mode+ - a :cl_filter_mode specifying the type of filter that must be applied when reading an image
+    # * +:mip_filter_mode+ - the filtering mode to use if using mimaps (default CL_FILTER_NONE, requires cl_khr_mipmap_image)
+    # * +:lod_min+ - floating point value representing the minimal LOD (default 0.0f, requires cl_khr_mipmap_image)
+    # * +:lod_max+ - floating point value representing the maximal LOD (default MAXFLOAT, requires cl_khr_mipmap_image)
+    def create_sampler( options = {} )
+      return OpenCL.create_sampler( self, options )
+    end
+
+    # Creates a Pipe in the Context
+    #
     # ==== Attributes
     #
-    # * +normalized_coords+ - a :cl_bool specifying if the image coordinates are normalized
-    # * +addressing_mode+ - a :cl_addressing_mode specifying how out-of-range image coordinates are handled when reading from an image
-    # * +filter_mode+ - a :cl_filter_mode specifying the type of filter that must be applied when reading an image
-    def create_sampler( normalized_coords, addressing_mode, filter_mode )
-      return OpenCL.create_sampler( self, normalized_coords, addressing_mode, filter_mode )
+    # * +pipe_packet_size+ - size of a packet in the Pipe
+    # * +pipe_max_packets+ - size of the Pipe in packet
+    #
+    # ==== Options
+    # 
+    # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
+    def create_pipe( pipe_packet_size, pipe_max_packets, opts = {} )
+      return OpenCL.create_pipe( self, pipe_packet_size, pipe_max_packets, opts )
     end
+
   end
 
 end

data/lib/opencl_ruby_ffi/Device.rb

@@ -68,11 +68,11 @@ module OpenCL
       eval OpenCL.get_info("Device", :cl_ulong, prop)
     }
 
-    %w( IMAGE_PITCH_ALIGNMENT IMAGE_BASE_ADDRESS_ALIGNMENT REFERENCE_COUNT PARTITION_MAX_SUB_DEVICES VENDOR_ID PREFERRED_VECTOR_WIDTH_HALF PREFERRED_VECTOR_WIDTH_CHAR PREFERRED_VECTOR_WIDTH_SHORT PREFERRED_VECTOR_WIDTH_INT PREFERRED_VECTOR_WIDTH_LONG PREFERRED_VECTOR_WIDTH_FLOAT PREFERRED_VECTOR_WIDTH_DOUBLE NATIVE_VECTOR_WIDTH_CHAR NATIVE_VECTOR_WIDTH_SHORT NATIVE_VECTOR_WIDTH_INT NATIVE_VECTOR_WIDTH_LONG NATIVE_VECTOR_WIDTH_FLOAT NATIVE_VECTOR_WIDTH_DOUBLE NATIVE_VECTOR_WIDTH_HALF MIN_DATA_TYPE_ALIGN_SIZE MEM_BASE_ADDR_ALIGN MAX_WRITE_IMAGE_ARGS MAX_WORK_ITEM_DIMENSIONS MAX_SAMPLERS MAX_READ_IMAGE_ARGS MAX_CONSTANT_ARGS MAX_COMPUTE_UNITS MAX_CLOCK_FREQUENCY ADDRESS_BITS GLOBAL_MEM_CACHELINE_SIZE ).each { |prop|
+    %w( IMAGE_PITCH_ALIGNMENT IMAGE_BASE_ADDRESS_ALIGNMENT REFERENCE_COUNT PARTITION_MAX_SUB_DEVICES VENDOR_ID PREFERRED_VECTOR_WIDTH_HALF PREFERRED_VECTOR_WIDTH_CHAR PREFERRED_VECTOR_WIDTH_SHORT PREFERRED_VECTOR_WIDTH_INT PREFERRED_VECTOR_WIDTH_LONG PREFERRED_VECTOR_WIDTH_FLOAT PREFERRED_VECTOR_WIDTH_DOUBLE NATIVE_VECTOR_WIDTH_CHAR NATIVE_VECTOR_WIDTH_SHORT NATIVE_VECTOR_WIDTH_INT NATIVE_VECTOR_WIDTH_LONG NATIVE_VECTOR_WIDTH_FLOAT NATIVE_VECTOR_WIDTH_DOUBLE NATIVE_VECTOR_WIDTH_HALF MIN_DATA_TYPE_ALIGN_SIZE MEM_BASE_ADDR_ALIGN MAX_WRITE_IMAGE_ARGS MAX_READ_WRITE_IMAGE_ARGS MAX_WORK_ITEM_DIMENSIONS MAX_SAMPLERS MAX_READ_IMAGE_ARGS MAX_CONSTANT_ARGS MAX_COMPUTE_UNITS MAX_CLOCK_FREQUENCY ADDRESS_BITS GLOBAL_MEM_CACHELINE_SIZE QUEUE_ON_DEVICE_PREFERRED_SIZE QUEUE_ON_DEVICE_MAX_SIZE MAX_ON_DEVICE_QUEUES MAX_ON_DEVICE_EVENTS MAX_PIPE_ARGS PIPE_MAX_ACTIVE_RESERVATIONS PIPE_MAX_PACKET_SIZE PREFERRED_PLATFORM_ATOMIC_ALIGNMENT PREFERRED_GLOBAL_ATOMIC_ALIGNMENT PREFERRED_LOCAL_ATOMIC_ALIGNMENT).each { |prop|
       eval OpenCL.get_info("Device", :cl_uint, prop)
     }
 
-    %w( PRINTF_BUFFER_SIZE IMAGE_MAX_BUFFER_SIZE IMAGE_MAX_ARRAY_SIZE PROFILING_TIMER_RESOLUTION MAX_WORK_GROUP_SIZE MAX_PARAMETER_SIZE IMAGE2D_MAX_WIDTH IMAGE2D_MAX_HEIGHT IMAGE3D_MAX_WIDTH IMAGE3D_MAX_HEIGHT IMAGE3D_MAX_DEPTH ).each { |prop|
+    %w( PRINTF_BUFFER_SIZE IMAGE_MAX_BUFFER_SIZE IMAGE_MAX_ARRAY_SIZE PROFILING_TIMER_RESOLUTION MAX_WORK_GROUP_SIZE MAX_PARAMETER_SIZE IMAGE2D_MAX_WIDTH IMAGE2D_MAX_HEIGHT IMAGE3D_MAX_WIDTH IMAGE3D_MAX_HEIGHT IMAGE3D_MAX_DEPTH MAX_GLOBAL_VARIABLE_SIZE GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE).each { |prop|
       eval OpenCL.get_info("Device", :size_t, prop)
     }
 
@@ -104,6 +104,16 @@ module OpenCL
     # Returns a CommandQueue::Properties representing the properties supported by a CommandQueue targetting the Device
     eval OpenCL.get_info("Device", :cl_command_queue_properties, "QUEUE_PROPERTIES")
 
+    ##
+    # :method: queue_on_device_properties()
+    # Returns a CommandQueue::Properties representing the properties supported by a CommandQueue on the Device
+    eval OpenCL.get_info("Device", :cl_command_queue_properties, "QUEUE_ON_DEVICE_PROPERTIES")
+
+    ##
+    # :method: queue_on_host_properties()
+    # Returns a CommandQueue::Properties representing the properties supported by a CommandQueue targetting the Device
+    eval OpenCL.get_info("Device", :cl_command_queue_properties, "QUEUE_ON_HOST_PROPERTIES")
+
     ##
     # :method: type()
     # Returns a Device::Type representing the type of the Device
@@ -124,6 +134,11 @@ module OpenCL
     # Returns the list of partition types supported by the Device
     eval OpenCL.get_info_array("Device", :cl_device_partition_property, "PARTITION_PROPERTIES")
 
+    ##
+    # :method: svm_capabilities()
+    # Returns an SVMCapabilities representing the the SVM capabilities corresponding to the device
+    eval OpenCL.get_info_array("Device", :cl_device_svm_capabilities, "SVM_CAPABILITIES")
+
     # Return an Array of partition properties names representing the partition type supported by the device
     def partition_properties_names
       prop_names = []

data/lib/opencl_ruby_ffi/Image.rb

@@ -6,11 +6,11 @@ module OpenCL
   #
   # * +context+ - Context the created Image will be associated to
   # * +format+ - an ImageFormat
-  # * +options+ - an ImageDesc
+  # * +desc+ - an ImageDesc
   #
   # ==== Options
   # 
-  # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
+  # * +: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
   def self.create_image( context, format, desc, options = {} )
     flags = OpenCL.get_flags( options )
@@ -31,9 +31,9 @@ module OpenCL
   #
   # ==== Options
   # 
-  # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
+  # * +: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
-  def self.create_image_1D( context, format, width, options )
+  def self.create_image_1D( context, format, width, options = {} )
     if context.platform.version_number > 1.1 then
       desc = OpenCL::ImageDesc::new(OpenCL::Mem::IMAGE1D, width, 0, 0, 0, 0, 0, 0, 0, nil)
       return OpenCL.create_image( context, format, desc, options )
@@ -52,7 +52,7 @@ module OpenCL
   #
   # ==== Options
   # 
-  # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
+  # * +: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
   # * +:row_pitch+ - if provided the row_pitch of data in host_ptr
   def self.create_image_2D( context, format, width, height, options = {} )
@@ -80,7 +80,7 @@ module OpenCL
   #
   # ==== Options
   # 
-  # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
+  # * +: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
   # * +:row_pitch+ - if provided the row_pitch of data in host_ptr
   # * +:slice_pitch+ - if provided the slice_pitch of data in host_ptr

data/lib/opencl_ruby_ffi/Kernel.rb

@@ -16,9 +16,9 @@ module OpenCL
 
   # 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 )
-    kernel_ptr = OpenCL.clCreateKernel(program, name, pointer_err)
-    OpenCL.error_check(pointer_err.read_cl_int)
+    error = FFI::MemoryPointer::new( :cl_int )
+    kernel_ptr = OpenCL.clCreateKernel(program, name, error)
+    OpenCL.error_check(error.read_cl_int)
     return OpenCL::Kernel::new( kernel_ptr, false )
   end
 
@@ -104,7 +104,11 @@ module OpenCL
 
       # Sets this Arg to value. The size of value can be specified.
       def set(value, size = nil)
-        OpenCL.set_kernel_arg(@kernel, @index, value, size)
+        if value.class == OpenCL::SVMPointer and @kernel.context.platform.version_number >= 2.0 then
+          OpenCL.set_kernel_arg_svm_pointer( @kernel, @index, value )
+        else
+          OpenCL.set_kernel_arg(@kernel, @index, value, size)
+        end
       end
 
     end
@@ -119,6 +123,29 @@ module OpenCL
       return a
     end
 
+    # Specifies the list of SVM pointers the kernel will be using
+    def set_svm_ptrs( ptrs )
+      OpenCL.error_check(OpenCL::INVALID_OPERATION) if self.context.platform.version_number < 2.0
+      pointers = [ptrs].flatten
+      pt = FFI::MemoryPointer::new( :pointer, pointers.length )
+      pointers.each_with_index { |p, i|
+        pt[i].write_pointer(p)
+      }
+      error = OpenCL.clSetKernelExecInfo( self, OpenCL::Kernel::EXEC_INFO_SVM_PTRS, pt.size, pt)
+      OpenCL.error_check(error)
+      return self
+    end
+
+    # Specifies the granularity of the SVM system.
+    def set_svm_fine_grain_system( flag )
+      OpenCL.error_check(OpenCL::INVALID_OPERATION) if self.context.platform.version_number < 2.0
+      pt = FFI::MemoryPointer::new(  :cl_bool )
+      pt.write_cl_bool( flag )
+      error = OpenCL.clSetKernelExecInfo( self, OpenCL::Kernel::EXEC_INFO_SVM_FINE_GRAIN_SYSTEL, pt.size, pt)
+      OpenCL.error_check(error)
+      return self
+    end
+
     ##
     # :method: function_name()
     # returns a String correspondig to the Kernel function name
@@ -164,6 +191,11 @@ module OpenCL
       OpenCL.set_kernel_arg(self, index, value, size)
     end
 
+    # Set the index th argument of the Kernel to an svm pointer value.
+    def set_arg_svm_pointer(index, svm_pointer)
+      OpenCL.set_kernel_arg_svm_pointer(self, index, svm_pointer)
+    end
+
     # Enqueues the Kernel in the given queue, specifying the global_work_size. Arguments for the kernel are specified afterwards. Last, a hash containing options for enqueuNDrange kernel can be specified
     def enqueue_with_args(command_queue, global_work_size, *args)
       n = self.num_args
@@ -175,7 +207,11 @@ module OpenCL
         options = {}
       end
       n.times { |i|
-        self.set_arg(i, args[i])
+        if args[i].class == OpenCL::SVMPointer and self.context.platform.version_number >= 2.0 then
+          self.set_arg_svm_pointer(i, args[i])
+        else
+          self.set_arg(i, args[i])
+        end
       }
       command_queue.enqueue_NDrange_kernel(self, global_work_size, options)
     end

data/lib/opencl_ruby_ffi/Mem.rb

@@ -65,6 +65,11 @@ module OpenCL
       eval OpenCL.get_info("Mem", :cl_uint, prop)
     }
 
+    ##
+    # :method: uses_svn_pointer()
+    # Returns true if Mem uses an SVM pointer
+    eval OpenCL.get_info("Mem", :cl_bool, "USES_SVM_POINTER")
+
     ##
     # :method: type()
     # Returns an OpenCL::Mem::Type corresponding to the Mem

data/lib/opencl_ruby_ffi/Pipe.rb

@@ -0,0 +1,38 @@
+module OpenCL
+
+  # Creates a Pipe
+  #
+  # ==== Attributes
+  #
+  # * +context+ - Context the created Pipe will be associated to
+  # * +pipe_packet_size+ - size of a packet in the Pipe
+  # * +pipe_max_packets+ - size of the Pipe in packet
+  #
+  # ==== Options
+  # 
+  # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Pipe
+  def self.create_pipe( context, pipe_packet_size, pipe_max_packets, options = {} )
+    OpenCL.error_check(OpenCL::INVALID_OPERATION) if self.context.platform.version_number < 2.0
+    flags = OpenCL.get_flags( options )
+    error = FFI::MemoryPointer::new( :cl_int )
+    pipe_ptr = OpenCL::clCreatePipe( context, flags, pipe_packet_size, pipe_max_packets, nil, error)
+    OpenCL.error_check(error.read_cl_int)
+    return OpenCL::Pipe::new(pipe_ptr, false)
+  end
+
+  class Pipe
+    
+    ##
+    # :method: packet_size
+    # Returns the packet_size of the Pipe
+
+    ##
+    # :method: max_packets
+    # Returns the max_packets of the Pipe
+    %w( PACKET_SIZE MAX_PACKETS ).each { |prop|
+      eval OpenCL.get_info("Pipe", :cl_uint, prop)
+    }
+
+  end
+
+end