opencl_ruby_ffi 0.993 → 0.994

data/lib/opencl_ruby_ffi/Pipe.rb

@@ -12,12 +12,12 @@ module OpenCL
   # 
   # * +: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_check(INVALID_OPERATION) if self.context.platform.version_number < 2.0
+    flags = 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)
+    pipe_ptr = clCreatePipe( context, flags, pipe_packet_size, pipe_max_packets, nil, error)
+    error_check(error.read_cl_int)
+    return Pipe::new(pipe_ptr, false)
   end
 
   # Maps the cl_mem OpenCL objects of type CL_MEM_OBJECT_PIPE

data/lib/opencl_ruby_ffi/Platform.rb

@@ -6,16 +6,16 @@ module OpenCL
   #
   # * +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)
+    error_check(INVALID_OPERATION) if self.version_number < 1.2
+    error = clUnloadPlatformCompiler( platform )
+    error_check(error)
     return platform
   end
 
   # Unloads the compiler
   def self.unload_compiler
-    error = OpenCL.clUnloadCompiler()
-    OpenCL.error_check(error)
+    error = clUnloadCompiler()
+    error_check(error)
     return nil
   end
 
@@ -29,7 +29,7 @@ module OpenCL
   # * +options+ - if given, a hash of named options that will be given to FFI::Function::new. See FFI doc for details.
   def self.get_extension_function( name, return_type, param_types, options = {} )
     name_p = FFI::MemoryPointer.from_string(name)
-    ptr = OpenCL.clGetExtensionFunctionAddress( name_p )
+    ptr = clGetExtensionFunctionAddress( name_p )
     return nil if ptr.null?
     return FFI::Function::new(return_type, param_types, ptr, options)
   end
@@ -44,9 +44,9 @@ module OpenCL
   # * +param_types+ - an Array of types, corresponding to the parameters type
   # * +options+ - if given, a hash of named options that will be given to FFI::Function::new. See FFI doc for details.
   def self.get_extension_function_for_platform( platform, name, return_type, param_types, options = {} )
-    OpenCL.error_check(OpenCL::INVALID_OPERATION) if self.version_number < 1.2
+    error_check(INVALID_OPERATION) if self.version_number < 1.2
     name_p = FFI::MemoryPointer.from_string(name)
-    ptr = OpenCL.clGetExtensionFunctionAddressForPlatform( platform, name_p )
+    ptr = clGetExtensionFunctionAddressForPlatform( platform, name_p )
     return nil if ptr.null?
     return FFI::Function::new(return_type, param_types, ptr, options)
   end
@@ -55,13 +55,13 @@ module OpenCL
   def self.get_platforms
     ptr1 = FFI::MemoryPointer::new(:cl_uint , 1)
     
-    error = OpenCL::clGetPlatformIDs(0, nil, ptr1)
-    OpenCL.error_check(error)
+    error = clGetPlatformIDs(0, nil, ptr1)
+    error_check(error)
     ptr2 = FFI::MemoryPointer::new(:pointer, ptr1.read_uint)
-    error = OpenCL::clGetPlatformIDs(ptr1.read_uint(), ptr2, nil)
-    OpenCL.error_check(error)
+    error = clGetPlatformIDs(ptr1.read_uint(), ptr2, nil)
+    error_check(error)
     return ptr2.get_array_of_pointer(0,ptr1.read_uint()).collect { |platform_ptr|
-      OpenCL::Platform::new(platform_ptr, false)
+      Platform::new(platform_ptr, false)
     }
   end
 
@@ -94,10 +94,10 @@ module OpenCL
     # Returns an Array of string corresponding to the Platform extensions
     def extensions
       extensions_size = FFI::MemoryPointer::new( :size_t )
-      error = OpenCL.clGetPlatformInfo( self, OpenCL::Platform::EXTENSIONS, 0, nil, extensions_size)
+      error = OpenCL.clGetPlatformInfo( self, EXTENSIONS, 0, nil, extensions_size)
       OpenCL.error_check(error)
       ext = FFI::MemoryPointer::new( extensions_size.read_size_t )
-      error = OpenCL.clGetPlatformInfo( self, OpenCL::Platform::EXTENSIONS, extensions_size.read_size_t, ext, nil)
+      error = OpenCL.clGetPlatformInfo( self, EXTENSIONS, extensions_size.read_size_t, ext, nil)
       OpenCL.error_check(error)
       ext_string = ext.read_string
       return ext_string.split(" ")
@@ -107,10 +107,10 @@ module OpenCL
     # The type of the desired devices can be specified
     def devices(type = OpenCL::Device::Type::ALL)
       ptr1 = FFI::MemoryPointer::new(:cl_uint , 1)
-      error = OpenCL::clGetDeviceIDs(self, type, 0, nil, ptr1)
+      error = OpenCL.clGetDeviceIDs(self, type, 0, nil, ptr1)
       OpenCL.error_check(error)
       ptr2 = FFI::MemoryPointer::new(:pointer, ptr1.read_uint)
-      error = OpenCL::clGetDeviceIDs(self, type, ptr1.read_uint(), ptr2, nil)
+      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, false)

data/lib/opencl_ruby_ffi/Program.rb

@@ -29,8 +29,8 @@ module OpenCL
     opt = ""
     opt = options[:options] if options[:options]
     options_p = FFI::MemoryPointer.from_string(opt)
-    error = OpenCL.clBuildProgram(program, num_devices, devices_p, options_p, block, options[:user_data] )
-    OpenCL.error_check(error)
+    error = clBuildProgram(program, num_devices, devices_p, options_p, block, options[:user_data] )
+    error_check(error)
     return program
   end
 
@@ -71,9 +71,9 @@ module OpenCL
       programs_p[i].write_pointer(e)
     }
     error = FFI::MemoryPointer::new( :cl_int )
-    prog = OpenCL.clLinkProgram( context, num_devices, devices_p, options_p, num_programs, programs_p, block, options[:user_data], error)
-    OpenCL.error_check(error.read_cl_int)
-    return OpenCL::Program::new( prog, false )
+    prog = clLinkProgram( context, num_devices, devices_p, options_p, num_programs, programs_p, block, options[:user_data], error)
+    error_check(error.read_cl_int)
+    return Program::new( prog, false )
   end
 
   # Compiles a Program created from sources
@@ -121,8 +121,8 @@ module OpenCL
         indx = indx + 1
       }
     end
-    error = OpenCL.clCompileProgram(program, num_devices, devices_p, options_p, num_headers, headers_p, header_include_names, block, options[:user_data] )
-    OpenCL.error_check(error)
+    error = clCompileProgram(program, num_devices, devices_p, options_p, num_headers, headers_p, header_include_names, block, options[:user_data] )
+    error_check(error)
     return program
   end
 
@@ -143,9 +143,9 @@ module OpenCL
     names = [kernel_names].flatten.join(",")
     names_p = FFI::MemoryPointer.from_string(names)
     error = FFI::MemoryPointer::new( :cl_int )
-    prog = OpenCL.clCreateProgramWithBuiltInKernels( context, num_devices, devices_p, names_p, error )
-    OpenCL.error_check(error.read_cl_int)
-    return OpenCL::Program::new(prog, false)
+    prog = clCreateProgramWithBuiltInKernels( context, num_devices, devices_p, names_p, error )
+    error_check(error.read_cl_int)
+    return Program::new(prog, false)
   end
 
   # Creates a Program from binary
@@ -153,13 +153,13 @@ module OpenCL
   # ==== Attributes
   #
   # * +context+ - Context the created Program will be associated to
-  # * +device_list+ - an Array of Device to create the program for. Can throw an OpenCL::Invalid value if the number of supplied devices is different from the number of supplied binaries.
+  # * +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
     devices = [device_list].flatten
-    OpenCL.error_check(OpenCL::INVALID_VALUE) if devices.length != bins.length
+    error_check(INVALID_VALUE) if devices.length != bins.length
     devices_p = FFI::MemoryPointer::new( Device, num_devices )
     lengths = FFI::MemoryPointer::new( :size_t, num_devices )
     binaries_p = FFI::MemoryPointer::new( :pointer, num_devices )
@@ -172,13 +172,13 @@ module OpenCL
     }
     binary_status = FFI::MemoryPointer::new( :cl_int, num_devices )
     error = FFI::MemoryPointer::new( :cl_int )
-    prog = OpenCL.clCreateProgramWithBinary(context, num_devices, devices_p, lengths, binaries_p, binary_status, error)
-    OpenCL.error_check(error.read_cl_int)
+    prog = clCreateProgramWithBinary(context, num_devices, devices_p, lengths, binaries_p, binary_status, error)
+    error_check(error.read_cl_int)
     d_s = []
     num_devices.times { |indx|
       d_s.push [ devices[indx], binary_status[indx].read_cl_int ]
     }
-    return [ OpenCL::Program::new(prog, false), d_s ]
+    return [ Program::new(prog, false), d_s ]
   end
 
   # Creates a Program from sources
@@ -190,7 +190,7 @@ module OpenCL
   def self.create_program_with_source(context, strings)
     strs = nil
     if not strings then
-      OpenCL.error_check(OpenCL::INVALID_VALUE)
+      error_check(INVALID_VALUE)
     else
       strs = [strings].flatten
     end
@@ -204,7 +204,7 @@ module OpenCL
         c_strs_p.push (FFI::MemoryPointer.from_string(str))
       end
     }
-    OpenCL.error_check(OpenCL::INVALID_VALUE) if c_strs_p.size == 0
+    error_check(INVALID_VALUE) if c_strs_p.size == 0
 
     c_strs = FFI::MemoryPointer::new( :pointer, c_strs_p.size )
     c_strs_length = FFI::MemoryPointer::new( :size_t, c_strs_p.size )
@@ -213,9 +213,9 @@ module OpenCL
       c_strs_length[i].write_size_t(p.size)
     }
     error = FFI::MemoryPointer::new( :cl_int )
-    program_ptr = OpenCL.clCreateProgramWithSource(context, c_strs_p.size, c_strs, c_strs_length, error)
-    OpenCL.error_check(error.read_cl_int)
-    return OpenCL::Program::new( program_ptr, false )
+    program_ptr = clCreateProgramWithSource(context, c_strs_p.size, c_strs, c_strs_length, error)
+    error_check(error.read_cl_int)
+    return Program::new( program_ptr, false )
   end
 
   # Maps the cl_program object of OpenCL
@@ -248,10 +248,10 @@ module OpenCL
     # Returns an Array of String representing the Kernel names inside the Program
     def kernel_names
       kernel_names_size = FFI::MemoryPointer::new( :size_t )
-      error = OpenCL.clGetProgramInfo( self, OpenCL::Program::KERNEL_NAMES, 0, nil, kernel_names_size)
+      error = OpenCL.clGetProgramInfo( self, KERNEL_NAMES, 0, nil, kernel_names_size)
       OpenCL.error_check(error)
       k_names = FFI::MemoryPointer::new( kernel_names_size.read_size_t )
-      error = OpenCL.clGetProgramInfo( self, OpenCL::Program::KERNEL_NAMES, kernel_names_size.read_size_t, k_names, nil)
+      error = OpenCL.clGetProgramInfo( self, KERNEL_NAMES, kernel_names_size.read_size_t, k_names, nil)
       OpenCL.error_check(error)
       k_names_string = k_names.read_string
       returns k_names_string.split(";")
@@ -266,7 +266,7 @@ module OpenCL
       devs = [devs].flatten
       ptr = FFI::MemoryPointer::new( :size_t )
       return devs.collect { |dev|
-        error = OpenCL.clGetProgramBuildInfo(self, dev, OpenCL::Program::BUILD_GLOBAL_VARIABLE_TOTAL_SIZE, ptr.size, ptr, nil)
+        error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_GLOBAL_VARIABLE_TOTAL_SIZE, ptr.size, ptr, nil)
         OpenCL.error_check(error)
         [dev, ptr.read_size_t]
       }
@@ -278,7 +278,7 @@ module OpenCL
       devs = [devs].flatten
       ptr = FFI::MemoryPointer::new( :cl_build_status )
       return devs.collect { |dev|
-        error = OpenCL.clGetProgramBuildInfo(self, dev, OpenCL::Program::BUILD_STATUS, ptr.size, ptr, nil)
+        error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_STATUS, ptr.size, ptr, nil)
         OpenCL.error_check(error)
         [dev, OpenCL::BuildStatus::new(ptr.read_cl_build_status)]
       }
@@ -290,7 +290,7 @@ module OpenCL
       devs = [devs].flatten
       ptr = FFI::MemoryPointer::new( :cl_program_binary_type )
       return devs.collect { |dev|
-        error = OpenCL.clGetProgramBuildInfo(self, dev, OpenCL::Program::BINARY_TYPE, ptr.size, ptr, nil)
+        error = OpenCL.clGetProgramBuildInfo(self, dev, BINARY_TYPE, ptr.size, ptr, nil)
         OpenCL.error_check(error)
         [dev, OpenCL::Program::BinaryType::new(ptr.read_cl_program_binary_type)]
       }
@@ -302,10 +302,10 @@ module OpenCL
       devs = [devs].flatten
       return devs.collect { |dev|
         ptr1 = FFI::MemoryPointer::new( :size_t, 1)
-        error = OpenCL.clGetProgramBuildInfo(self, dev, OpenCL::Program::BUILD_OPTIONS, 0, nil, ptr1)
+        error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_OPTIONS, 0, nil, ptr1)
         OpenCL.error_check(error)
         ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
-        error = OpenCL.clGetProgramBuildInfo(self, dev, OpenCL::Program::BUILD_OPTIONS, ptr1.read_size_t, ptr2, nil)
+        error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_OPTIONS, ptr1.read_size_t, ptr2, nil)
         OpenCL.error_check(error)
         [dev, ptr2.read_string]
       }
@@ -317,10 +317,10 @@ module OpenCL
       devs = [devs].flatten
       return devs.collect { |dev|
         ptr1 = FFI::MemoryPointer::new( :size_t, 1)
-        error = OpenCL.clGetProgramBuildInfo(self, dev, OpenCL::Program::BUILD_LOG, 0, nil, ptr1)
+        error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_LOG, 0, nil, ptr1)
         OpenCL.error_check(error)
         ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
-        error = OpenCL.clGetProgramBuildInfo(self, dev, OpenCL::Program::BUILD_LOG, ptr1.read_size_t, ptr2, nil)
+        error = OpenCL.clGetProgramBuildInfo(self, dev, BUILD_LOG, ptr1.read_size_t, ptr2, nil)
         OpenCL.error_check(error)
         [dev, ptr2.read_string]
       }
@@ -336,7 +336,7 @@ module OpenCL
         total_size += s
         bin_array[i].write_pointer(FFI::MemoryPointer::new(s))
       }
-      error = OpenCL.clGetProgramInfo(self, OpenCL::Program::BINARIES, total_size, bin_array, nil)
+      error = OpenCL.clGetProgramInfo(self, BINARIES, total_size, bin_array, nil)
       OpenCL.error_check(error)
       bins = []
       devs = self.devices
@@ -381,7 +381,7 @@ module OpenCL
     # Returns the Context the Program is associated to
     def context
       ptr = FFI::MemoryPointer::new( Context )
-      error = OpenCL.clGetProgramInfo(self, OpenCL::Program::CONTEXT, Context.size, ptr, nil)
+      error = OpenCL.clGetProgramInfo(self, CONTEXT, Context.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Context::new( ptr.read_pointer )
     end
@@ -401,7 +401,7 @@ module OpenCL
     def devices
       n = self.num_devices
       ptr2 = FFI::MemoryPointer::new( Device, n )
-      error = OpenCL.clGetProgramInfo(self, OpenCL::Program::DEVICES, Device.size*n, ptr2, nil)
+      error = OpenCL.clGetProgramInfo(self, DEVICES, Device.size*n, ptr2, nil)
       OpenCL.error_check(error)
       return ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
         OpenCL::Device::new(device_ptr)

data/lib/opencl_ruby_ffi/SVM.rb

@@ -11,7 +11,7 @@ module OpenCL
 
     # creates a new SVMPointer relative to an existing one from an offset
     def +( offset )
-      return OpenCL::SVMPointer::new(  self.address + offset, @context )
+      return SVMPointer::new(  self.address + offset, @context )
     end
 
     # frees the SVMPointer (must not be called on an SVMPointer obtained from an offset)
@@ -34,13 +34,13 @@ module OpenCL
   #
   # * +:alignment+ - imposes the minimum alignment in byte
   def self.svm_alloc(context, size, options = {})
-    OpenCL.error_check(OpenCL::INVALID_OPERATION) if context.platform.version_number < 2.0
-    flags = OpenCL::get_flags(options)
+    error_check(INVALID_OPERATION) if context.platform.version_number < 2.0
+    flags = get_flags(options)
     alignment = 0
     alignment = options[:alignment] if options[:alignment]
-    ptr = OpenCL.clSVMAlloc( context, flags, size, alignment )
-    OpenCL.error_check(OpenCL::MEM_OBJECT_ALLOCATION_FAILURE) if ptr.null?
-    return OpenCL::SVMPointer::new( ptr, context )
+    ptr = clSVMAlloc( context, flags, size, alignment )
+    error_check(MEM_OBJECT_ALLOCATION_FAILURE) if ptr.null?
+    return SVMPointer::new( ptr, context )
   end
 
   # Frees an SVMPointer
@@ -50,15 +50,15 @@ module OpenCL
   # * +context+ - the Context in which to deallocate the memory
   # * +svm_pointer+ - the SVMPointer to deallocate
   def self.svm_free(context, svm_pointer)
-    OpenCL.error_check(OpenCL::INVALID_OPERATION) if context.platform.version_number < 2.0
-    return OpenCL.clSVMFree( context, svm_pointer )
+    error_check(INVALID_OPERATION) if context.platform.version_number < 2.0
+    return clSVMFree( context, svm_pointer )
   end
 
   # Set the index th argument of Kernel to value. Value must be within a SVM memory area
   def self.set_kernel_arg_svm_pointer( kernel, index, value )
-    OpenCL.error_check(OpenCL::INVALID_OPERATION) if kernel.context.platform.version_number < 2.0
-    error = OpenCL.clSetKernelArgSVMPointer( kernel, index, val )
-    OpenCL.error_check(error)
+    error_check(INVALID_OPERATION) if kernel.context.platform.version_number < 2.0
+    error = clSetKernelArgSVMPointer( kernel, index, val )
+    error_check(error)
     return kernel
   end
 
@@ -86,11 +86,11 @@ module OpenCL
     pointers.each_with_index { |p, indx|
       ptr[indx].write_pointer(p)
     }
-    num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer::new( OpenCL::Event )
-    error = OpenCL.clEnqueueSVMFree(command_queue, num_pointers, ptr, block, options[:user_data], num_events, events, event)
-    OpenCL.error_check(error)
-    return OpenCL::Event::new(event.read_pointer, false)
+    num_events, events = get_event_wait_list( options )
+    event = FFI::MemoryPointer::new( Event )
+    error = clEnqueueSVMFree(command_queue, num_pointers, ptr, block, options[:user_data], num_events, events, event)
+    error_check(error)
+    return Event::new(event.read_pointer, false)
   end
 
   # Enqueues a command to copy from or to an SVMPointer
@@ -113,14 +113,14 @@ module OpenCL
   #
   # the Event associated with the command
   def self.enqueue_svm_memcpy(command_queue, dst_ptr, src_ptr, size, options = {})
-    OpenCL.error_check(OpenCL::INVALID_OPERATION) if command_queue.context.platform.version_number < 2.0
-    blocking = OpenCL::FALSE
-    blocking = OpenCL::TRUE if options[:blocking] or options[:blocking_copy]
-    num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer::new( OpenCL::Event )
-    error = OpenCL.clEnqueueSVMMemcpy(command_queue, blocking, dst_ptr, src_ptr, size, num_events, events, event)
-    OpenCL.error_check(error)
-    return OpenCL::Event::new(event.read_pointer, false)
+    error_check(INVALID_OPERATION) if command_queue.context.platform.version_number < 2.0
+    blocking = FALSE
+    blocking = TRUE if options[:blocking] or options[:blocking_copy]
+    num_events, events = get_event_wait_list( options )
+    event = FFI::MemoryPointer::new( Event )
+    error = clEnqueueSVMMemcpy(command_queue, blocking, dst_ptr, src_ptr, size, num_events, events, event)
+    error_check(error)
+    return Event::new(event.read_pointer, false)
   end
 
   # Enqueues a command to fill a an SVM memory area
@@ -141,13 +141,13 @@ module OpenCL
   #
   # the Event associated with the command
   def self.enqueue_svm_fill(command_queue, svm_ptr, pattern, size, options = {})
-    num_events, events = OpenCL.get_event_wait_list( options )
+    num_events, events = get_event_wait_list( options )
     pattern_size = pattern.size
     pattern_size = options[:pattern_size] if options[:pattern_size]
-    event = FFI::MemoryPointer::new( OpenCL::Event )
-    error = OpenCL.clEnqueueSVMFill(command_queue, svm_ptr, pattern, pattern_size, size, num_events, events, event)
-    OpenCL.error_check(error)
-    return OpenCL::Event::new(event.read_pointer, false)
+    event = FFI::MemoryPointer::new( Event )
+    error = clEnqueueSVMFill(command_queue, svm_ptr, pattern, pattern_size, size, num_events, events, event)
+    error_check(error)
+    return Event::new(event.read_pointer, false)
   end
 
   # Enqueues a command to map an Image into host memory
@@ -170,14 +170,14 @@ module OpenCL
   #
   # the Event associated with the command
   def self.enqueue_svm_map( command_queue, svm_ptr, size, map_flags, options = {} )
-    blocking = OpenCL::FALSE
-    blocking = OpenCL::TRUE if options[:blocking] or options[:blocking_map]
-    flags = OpenCL.get_flags( {:flags => map_flags} )
-    num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer::new( OpenCL::Event )
-    error = OpenCL.clEnqueueSVMMap( command_queue, blocking, flags, svm_ptr, size, num_events, events, event )
-    OpenCL.error_check( error.read_cl_int )
-    return OpenCL::Event::new( event.read_ptr, false )
+    blocking = FALSE
+    blocking = TRUE if options[:blocking] or options[:blocking_map]
+    flags = get_flags( {:flags => map_flags} )
+    num_events, events = get_event_wait_list( options )
+    event = FFI::MemoryPointer::new( Event )
+    error = clEnqueueSVMMap( command_queue, blocking, flags, svm_ptr, size, num_events, events, event )
+    error_check( error.read_cl_int )
+    return Event::new( event.read_ptr, false )
   end
 
   # Enqueues a command to unmap a previously mapped SVM memory area
@@ -196,11 +196,11 @@ module OpenCL
   #
   # the Event associated with the command
   def self.enqueue_svm_unmap( command_queue, svm_ptr, options = {} )
-    num_events, events = OpenCL.get_event_wait_list( options )
-    event = FFI::MemoryPointer::new( OpenCL::Event )
-    error = OpenCL.clEnqueueSVMUnmap( command_queue, svm_ptr, num_events, events, event )
-    OpenCL.error_check( error )
-    return OpenCL::Event::new( event.read_ptr, false )
+    num_events, events = get_event_wait_list( options )
+    event = FFI::MemoryPointer::new( Event )
+    error = clEnqueueSVMUnmap( command_queue, svm_ptr, num_events, events, event )
+    error_check( error )
+    return Event::new( event.read_ptr, false )
   end
 
 end

data/lib/opencl_ruby_ffi/Sampler.rb

@@ -15,48 +15,48 @@ module OpenCL
   # * +: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 self.create_sampler( context, options = {} )
-    normalized_coords = OpenCL::TRUE
+    normalized_coords = TRUE
     normalized_coords = options[:normalized_coords] if options[:normalized_coords]
-    addressing_mode = OpenCL::AddressingMode::CLAMP
+    addressing_mode = AddressingMode::CLAMP
     addressing_mode = options[:addressing_mode] if options[:addressing_mode]
-    filter_mode = OpenCL::FilterMode::NEAREST
+    filter_mode = FilterMode::NEAREST
     filter_mode = options[:filter_mode] if options[:filter_mode]
     error = FFI::MemoryPointer::new( :cl_int )
     if context.platform.version_number < 2.0 then
-      sampler_ptr = OpenCL.clCreateSampler( context, normalized_coords, addressing_mode, filter_mode, error )
+      sampler_ptr = clCreateSampler( context, normalized_coords, addressing_mode, filter_mode, error )
     else
       prop_size = 7
       prop_size += 2 if options[:mip_filter_mode]
       prop_size += 2 if options[:lod_min]
       prop_size += 2 if options[:lod_max]
       properties = FFI::MemoryPointer::new( :cl_sampler_properties)
-      properties[0].write_cl_sampler_properties( OpenCL::Sampler::NORMALIZED_COORDS )
+      properties[0].write_cl_sampler_properties( Sampler::NORMALIZED_COORDS )
       properties[1].write_cl_sampler_properties( normalized_coords )
-      properties[2].write_cl_sampler_properties( OpenCL::Sampler::ADDRESSING_MODE )
+      properties[2].write_cl_sampler_properties( Sampler::ADDRESSING_MODE )
       properties[3].write_cl_sampler_properties( addressing_mode )
-      properties[4].write_cl_sampler_properties( OpenCL::Sampler::FILTER_MODE )
+      properties[4].write_cl_sampler_properties( Sampler::FILTER_MODE )
       properties[5].write_cl_sampler_properties( filter_mode )
       prop_indx = 6
       if options[:mip_filter_mode] then
-        properties[prop_indx].write_cl_sampler_properties( OpenCL::Sampler::MIP_FILTER_MODE )
+        properties[prop_indx].write_cl_sampler_properties( Sampler::MIP_FILTER_MODE )
         properties[prop_indx+1].write_cl_sampler_properties( options[:mip_filter_mode] )
         prop_indx += 2
       end
       if options[:lod_min] then
-        properties[prop_indx].write_cl_sampler_properties( OpenCL::Sampler::LOD_MIN )
+        properties[prop_indx].write_cl_sampler_properties( Sampler::LOD_MIN )
         properties[prop_indx+1].write_float( options[:lod_min] )
         prop_indx += 2
       end
       if options[:lod_max] then
-        properties[prop_indx].write_cl_sampler_properties( OpenCL::Sampler::LOD_MAX )
+        properties[prop_indx].write_cl_sampler_properties( Sampler::LOD_MAX )
         properties[prop_indx+1].write_float( options[:lod_max] )
         prop_indx += 2
       end
       properties[prop_indx].write_cl_sampler_properties( 0 )
-      sampler_ptr = OpenCL.clCreateSamplerWithProperties( context, properties, error )
+      sampler_ptr = clCreateSamplerWithProperties( context, properties, error )
     end
-    OpenCL.error_check(error.read_cl_int)
-    OpenCL::Sampler::new(sampler_ptr, false)
+    error_check(error.read_cl_int)
+    Sampler::new(sampler_ptr, false)
   end
 
   # Maps the cl_smapler object of OpenCL
@@ -65,7 +65,7 @@ module OpenCL
     # Returns the context associated with the Sampler
     def context
       ptr = FFI::MemoryPointer::new( Context )
-      error = OpenCL.clGetSamplerInfo(self, Sampler::CONTEXT, Context.size, ptr, nil)
+      error = OpenCL.clGetSamplerInfo(self, CONTEXT, Context.size, ptr, nil)
       OpenCL.error_check(error)
       return OpenCL::Context::new( ptr.read_pointer )
     end

data/lib/opencl_ruby_ffi/opencl_ruby_ffi_base.rb

@@ -43,28 +43,28 @@ end
 
 module OpenCL
   @@type_converter = {
-    :cl_device_type => OpenCL::Device::Type,
-    :cl_device_fp_config => OpenCL::Device::FPConfig,
-    :cl_device_mem_cache_type => OpenCL::Device::MemCacheType,
-    :cl_device_local_mem_type => OpenCL::Device::LocalMemType,
-    :cl_device_exec_capabilities => OpenCL::Device::ExecCapabilities,
-    :cl_command_queue_properties => OpenCL::CommandQueue::Properties,
-    :cl_device_affinity_domain => OpenCL::Device::AffinityDomain,
-    :cl_device_svm_capabilities => OpenCL::Device::SVMCapabilities,
-    :cl_channel_order => OpenCL::ChannelOrder,
-    :cl_channel_type => OpenCL::ChannelType,
-    :cl_mem_flags => OpenCL::Mem::Flags,
-    :cl_mem_object_type => OpenCL::Mem::Type,
-    :cl_mem_migration_flags => OpenCL::Mem::MigrationFlags,
-    :cl_addressing_mode => OpenCL::AddressingMode,
-    :cl_filter_mode => OpenCL::FilterMode,
-    :cl_map_flags => OpenCL::MapFlags,
-    :cl_program_binary_type => OpenCL::Program::BinaryType,
-    :cl_kernel_arg_address_qualifier => OpenCL::Kernel::Arg::AddressQualifier,
-    :cl_kernel_arg_access_qualifier => OpenCL::Kernel::Arg::AccessQualifier,
-    :cl_kernel_arg_type_qualifier => OpenCL::Kernel::Arg::TypeQualifier,
-    :cl_command_type => OpenCL::CommandType,
-    :cl_build_status => OpenCL::BuildStatus
+    :cl_device_type => Device::Type,
+    :cl_device_fp_config => Device::FPConfig,
+    :cl_device_mem_cache_type => Device::MemCacheType,
+    :cl_device_local_mem_type => Device::LocalMemType,
+    :cl_device_exec_capabilities => Device::ExecCapabilities,
+    :cl_command_queue_properties => CommandQueue::Properties,
+    :cl_device_affinity_domain => Device::AffinityDomain,
+    :cl_device_svm_capabilities => Device::SVMCapabilities,
+    :cl_channel_order => ChannelOrder,
+    :cl_channel_type => ChannelType,
+    :cl_mem_flags => Mem::Flags,
+    :cl_mem_object_type => Mem::Type,
+    :cl_mem_migration_flags => Mem::MigrationFlags,
+    :cl_addressing_mode => AddressingMode,
+    :cl_filter_mode => FilterMode,
+    :cl_map_flags => MapFlags,
+    :cl_program_binary_type => Program::BinaryType,
+    :cl_kernel_arg_address_qualifier => Kernel::Arg::AddressQualifier,
+    :cl_kernel_arg_access_qualifier => Kernel::Arg::AccessQualifier,
+    :cl_kernel_arg_type_qualifier => Kernel::Arg::TypeQualifier,
+    :cl_command_type => CommandType,
+    :cl_build_status => BuildStatus
   }
   @@callbacks = []
 
@@ -196,7 +196,7 @@ module OpenCL
 
   # Extracts the :properties named option (for a CommandQueue) from the hash given and returns the properties values
   def self.get_command_queue_properties( options )
-    properties = OpenCL::CommandQueue::Properties::new(0)
+    properties = CommandQueue::Properties::new(0)
     if options[:properties] then
       if options[:properties].respond_to?(:each) then
         options[:properties].each { |f| properties = properties | f }
@@ -224,12 +224,12 @@ module OpenCL
       }
     else
        region[0].write_size_t( image.width - origin[0].read_size_t )
-       if image.type == OpenCL::Mem::IMAGE1D_ARRAY then
+       if image.type == Mem::IMAGE1D_ARRAY then
          region[1].write_size_t( image.array_size - origin[1].read_size_t )
        else
          region[1].write_size_t( image.height != 0 ? image.height - origin[1].read_size_t : 1 )
        end
-       if image.type == OpenCL::Mem::IMAGE2D_ARRAY then
+       if image.type == Mem::IMAGE2D_ARRAY then
          region[2].write_size_t( image.array_size - origin[2].read_size_t )
        else 
          region[2].write_size_t( image.depth != 0 ? image.depth - origin[2].read_size_t : 1 )
@@ -251,14 +251,14 @@ module OpenCL
     return properties
   end
 
-  # checks if a :cl_int corresponds to an Error code and raises the apropriate OpenCL::Error
+  # checks if a :cl_int corresponds to an error code and raises the apropriate Error
   def self.error_check(errcode)
     return nil if errcode == SUCCESS
-    klass = OpenCL::Error::CLASSES[errcode]
+    klass = Error::CLASSES[errcode]
     if klass then
       raise klass::new
     else
-      raise OpenCL::Error::new("#{errcode}")
+      raise Error::new("#{errcode}")
     end
   end
 
@@ -310,7 +310,7 @@ EOF
         error = OpenCL.clGet#{klass_name}Info(self, #{klass}::#{name}, ptr1.read_size_t, ptr2, nil)
         OpenCL.error_check(error)
 EOF
-    if(OpenCL::convert_type(type)) then
+    if(convert_type(type)) then
       s += <<EOF
         return OpenCL::convert_type(:#{type})::new(ptr2.read_#{type})
       end