opencl_ruby_ffi 0.994 → 0.995

data/lib/opencl_ruby_ffi/CommandQueue.rb

@@ -1040,37 +1040,42 @@ module OpenCL
 
   # Maps the cl_command_queue object of OpenCL
   class CommandQueue
+    include InnerInterface
+ 
+    class << self
+      include InnerGenerator
+    end
 
     # Returns the Context associated to the CommandQueue
     def context
-      ptr = FFI::MemoryPointer::new( OpenCL::Context )
+      ptr = FFI::MemoryPointer::new( Context )
       error = OpenCL.clGetCommandQueueInfo(self, CONTEXT, Context.size, ptr, nil)
-      OpenCL.error_check(error)
-      return OpenCL::Context::new( ptr.read_pointer )
+      error_check(error)
+      return Context::new( ptr.read_pointer )
     end
 
     # Returns the Device associated to the CommandQueue
     def device
-      ptr = FFI::MemoryPointer::new( OpenCL::Device )
+      ptr = FFI::MemoryPointer::new( Device )
       error = OpenCL.clGetCommandQueueInfo(self, DEVICE, Device.size, ptr, nil)
-      OpenCL.error_check(error)
-      return OpenCL::Device::new( ptr.read_pointer )
+      error_check(error)
+      return Device::new( ptr.read_pointer )
     end
 
     ##
     # :method: reference_count
     # Returns the reference count of the CommandQueue
-    eval OpenCL.get_info("CommandQueue", :cl_uint, "REFERENCE_COUNT")
+    eval 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")
+    eval get_info("CommandQueue", :cl_uint, "SIZE")
 
     ##
     # :method: properties
     # Returns the :cl_command_queue_properties used to create the CommandQueue
-    eval OpenCL.get_info("CommandQueue", :cl_command_queue_properties, "PROPERTIES")
+    eval get_info("CommandQueue", :cl_command_queue_properties, "PROPERTIES")
 
     # Enqueues a native kernel using the CommandQueue
     #  not yet fully implemented

data/lib/opencl_ruby_ffi/Context.rb

@@ -49,18 +49,23 @@ module OpenCL
 
   #Maps the cl_context object of OpenCL
   class Context
+    include InnerInterface
+
+    class << self
+      include InnerGenerator
+    end
 
     ##
     # :method: reference_count
     # Returns the reference count of the Context
     %w( REFERENCE_COUNT ).each { |prop|
-      eval OpenCL.get_info("Context", :cl_uint, prop)
+      eval get_info("Context", :cl_uint, prop)
     }
 
     ##
     # :method: properties
     # the Array of :cl_context_properties used to create the Context
-    eval OpenCL.get_info_array("Context", :cl_context_properties, "PROPERTIES")
+    eval get_info_array("Context", :cl_context_properties, "PROPERTIES")
 
     # Returns the platform associated to the Context
     def platform
@@ -71,8 +76,8 @@ module OpenCL
     def num_devices
       d_n = 0
       ptr = FFI::MemoryPointer::new( :size_t )
-      error = OpenCL.clGetContextInfo(self, OpenCL::Context::DEVICES, 0, nil, ptr)
-      OpenCL.error_check(error)
+      error = OpenCL.clGetContextInfo(self, DEVICES, 0, nil, ptr)
+      error_check(error)
       d_n = ptr.read_size_t / Platform.size
 #      else
 #        ptr = FFI::MemoryPointer::new( :cl_uint )
@@ -87,10 +92,10 @@ module OpenCL
     def devices
       n = self.num_devices
       ptr2 = FFI::MemoryPointer::new( Device, n )
-      error = OpenCL.clGetContextInfo(self, OpenCL::Context::DEVICES, Device.size*n, ptr2, nil)
-      OpenCL.error_check(error)
+      error = OpenCL.clGetContextInfo(self, DEVICES, Device.size*n, ptr2, nil)
+      error_check(error)
       return ptr2.get_array_of_pointer(0, n).collect { |device_ptr|
-        OpenCL::Device::new(device_ptr)
+        Device::new(device_ptr)
       }
     end
 
@@ -104,16 +109,16 @@ module OpenCL
     # 
     # * +:flags+ - a single or an Array of :cl_mem_flags specifying the flags to be used when creating the Buffer
     def supported_image_formats( image_type, options = {} )
-      flags = OpenCL.get_flags( options )
+      flags = get_flags( options )
       num_image_formats = FFI::MemoryPointer::new( :cl_uint )
       error = OpenCL.clGetSupportedImageFormats( self, flags, image_type, 0, nil, num_image_formats )
-      OpenCL.error_check(error)
+      error_check(error)
       num_entries = num_image_formats.read_cl_uint
       image_formats = FFI::MemoryPointer::new( ImageFormat, num_entries )
       error = OpenCL.clGetSupportedImageFormats( self, flags, image_type, num_entries, image_formats, nil )
-      OpenCL.error_check(error)
+      error_check(error)
       return num_entries.times.collect { |i|
-        OpenCL::ImageFormat::from_pointer( image_formats + i * ImageFormat.size )
+        ImageFormat::from_pointer( image_formats + i * ImageFormat.size )
       }
     end
 
@@ -334,7 +339,7 @@ module OpenCL
     #
     # * +device_list+ - an Array of Device to create the program for
     # * +kernel_names+ - a single or an Array of String representing the kernel names
-    def self.create_program_with_built_in_kernels( device_list, kernel_names )
+    def create_program_with_built_in_kernels( device_list, kernel_names )
       return OpenCL.create_program_with_built_in_kernels(self, device_list, kernel_names )
     end
 

data/lib/opencl_ruby_ffi/Device.rb

@@ -31,6 +31,11 @@ module OpenCL
 
   # Maps the cl_device_id object of OpenCL
   class Device
+    include InnerInterface
+
+    class << self
+      include InnerGenerator
+    end
 
     # :stopdoc:
     DRIVER_VERSION = 0x102D
@@ -40,10 +45,10 @@ module OpenCL
     def extensions
       extensions_size = FFI::MemoryPointer::new( :size_t )
       error = OpenCL.clGetDeviceInfo( self, EXTENSIONS, 0, nil, extensions_size)
-      OpenCL.error_check(error)
+      error_check(error)
       ext = FFI::MemoryPointer::new( extensions_size.read_size_t )
       error = OpenCL.clGetDeviceInfo( self, EXTENSIONS, extensions_size.read_size_t, ext, nil)
-      OpenCL.error_check(error)
+      error_check(error)
       ext_string = ext.read_string
       return ext_string.split(" ")
     end
@@ -52,92 +57,92 @@ module OpenCL
     def built_in_kernels
       built_in_kernels_size = FFI::MemoryPointer::new( :size_t )
       error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS, 0, nil, built_in_kernels_size)
-      OpenCL.error_check(error)
+      error_check(error)
       ker = FFI::MemoryPointer::new( built_in_kernels_size.read_size_t )
       error = OpenCL.clGetDeviceInfo( self, BUILT_IN_KERNELS, built_in_kernels_size.read_size_t, ker, nil)
-      OpenCL.error_check(error)
+      error_check(error)
       ker_string = ext.read_string
       return ker_string.split(";")
     end
 
     %w( BUILT_IN_KERNELS DRIVER_VERSION VERSION VENDOR PROFILE OPENCL_C_VERSION NAME ).each { |prop|
-      eval OpenCL.get_info("Device", :string, prop)
+      eval get_info("Device", :string, prop)
     }
 
     %w( MAX_MEM_ALLOC_SIZE MAX_CONSTANT_BUFFER_SIZE LOCAL_MEM_SIZE GLOBAL_MEM_CACHE_SIZE GLOBAL_MEM_SIZE ).each { |prop|
-      eval OpenCL.get_info("Device", :cl_ulong, prop)
+      eval 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_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)
+      eval 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 MAX_GLOBAL_VARIABLE_SIZE GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE).each { |prop|
-      eval OpenCL.get_info("Device", :size_t, prop)
+      eval get_info("Device", :size_t, prop)
     }
 
     %w( PREFERRED_INTEROP_USER_SYNC LINKER_AVAILABLE IMAGE_SUPPORT HOST_UNIFIED_MEMORY COMPILER_AVAILABLE AVAILABLE ENDIAN_LITTLE ERROR_CORRECTION_SUPPORT ).each { |prop|
-      eval OpenCL.get_info("Device", :cl_bool, prop)
+      eval get_info("Device", :cl_bool, prop)
     }
 
     %w( SINGLE_FP_CONFIG HALF_FP_CONFIG DOUBLE_FP_CONFIG ).each { |prop|
-      eval OpenCL.get_info("Device", :cl_device_fp_config, prop)
+      eval get_info("Device", :cl_device_fp_config, prop)
     }
 
     ##
     # :method: execution_capabilities()
     # Returns an ExecCpabilities representing the execution capabilities corresponding to the Device
-    eval OpenCL.get_info("Device", :cl_device_exec_capabilities, "EXECUTION_CAPABILITIES")
+    eval get_info("Device", :cl_device_exec_capabilities, "EXECUTION_CAPABILITIES")
 
     ##
     # :method: global_mem_cache_type()
     # Returns a MemCacheType representing the type of the global cache memory on the Device
-    eval OpenCL.get_info("Device", :cl_device_mem_cache_type, "GLOBAL_MEM_CACHE_TYPE")
+    eval get_info("Device", :cl_device_mem_cache_type, "GLOBAL_MEM_CACHE_TYPE")
 
     ##
     # :method: local_mem_type()
     # Returns a LocalMemType rpresenting the type of the local memory on the Device
-    eval OpenCL.get_info("Device", :cl_device_local_mem_type, "LOCAL_MEM_TYPE")
+    eval get_info("Device", :cl_device_local_mem_type, "LOCAL_MEM_TYPE")
 
     ##
     # :method: queue_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_PROPERTIES")
+    eval 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")
+    eval 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")
+    eval get_info("Device", :cl_command_queue_properties, "QUEUE_ON_HOST_PROPERTIES")
 
     ##
     # :method: type()
     # Returns a Device::Type representing the type of the Device
-    eval OpenCL.get_info("Device", :cl_device_type, "TYPE")
+    eval get_info("Device", :cl_device_type, "TYPE")
 
     ##
     # :method: partition_affinity_domain()
     # Returns an AffinityDomain representing the list of supported affinity domains for partitioning the Device using OpenCL::Device::PARTITION_BY_AFFINITY_DOMAIN
-    eval OpenCL.get_info("Device", :cl_device_affinity_domain, "PARTITION_AFFINITY_DOMAIN")
+    eval get_info("Device", :cl_device_affinity_domain, "PARTITION_AFFINITY_DOMAIN")
 
     ##
     # :method: max_work_item_sizes()
     # Maximum number of work-items that can be specified in each dimension of the work-group to clEnqueueNDRangeKernel for the Device
-    eval OpenCL.get_info_array("Device", :size_t, "MAX_WORK_ITEM_SIZES")
+    eval get_info_array("Device", :size_t, "MAX_WORK_ITEM_SIZES")
 
     ##
     # :method: partition_properties()
     # Returns the list of partition types supported by the Device
-    eval OpenCL.get_info_array("Device", :cl_device_partition_property, "PARTITION_PROPERTIES")
+    eval 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")
+    eval 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
@@ -151,13 +156,13 @@ module OpenCL
     ##
     # :method: partition_type()
     # Returns a list of :cl_device_partition_property used to create the Device
-    eval OpenCL.get_info_array("Device", :cl_device_partition_property, "PARTITION_TYPE")
+    eval get_info_array("Device", :cl_device_partition_property, "PARTITION_TYPE")
 
     # Returns the platform the Device belongs to
     def platform
       ptr = FFI::MemoryPointer::new( OpenCL::Platform )
       error = OpenCL.clGetDeviceInfo(self, PLATFORM, OpenCL::Platform.size, ptr, nil)
-      OpenCL.error_check(error)
+      error_check(error)
       return OpenCL::Platform::new(ptr.read_pointer)
     end
 
@@ -165,7 +170,7 @@ module OpenCL
     def parent_device
       ptr = FFI::MemoryPointer::new( Device )
       error = OpenCL.clGetDeviceInfo(self, PARENT_DEVICE, Device.size, ptr, nil)
-      OpenCL.error_check(error)
+      error_check(error)
       return nil if ptr.null?
       return Device::new(ptr.read_pointer)
     end

data/lib/opencl_ruby_ffi/Event.rb

@@ -67,73 +67,78 @@ module OpenCL
 
   # Maps the cl_event object
   class Event
+    include InnerInterface
+
+    class << self
+      include InnerGenerator
+    end
 
     # Returns the CommandQueue associated with the Event, if it exists
     def command_queue
-      ptr = FFI::MemoryPointer::new( OpenCL::CommandQueue )
-      error = OpenCL.clGetEventInfo(self, COMMAND_QUEUE, OpenCL::CommandQueue.size, ptr, nil)
-      OpenCL.error_check(error)
+      ptr = FFI::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 OpenCL::CommandQueue::new( pt )
+        return CommandQueue::new( pt )
       end
     end
 
     # Returns the Context associated with the Event
     def context
-      ptr = FFI::MemoryPointer::new( OpenCL::Context )
-      error = OpenCL.clGetEventInfo(self, CONTEXT, OpenCL::Context.size, ptr, nil)
-      OpenCL.error_check(error)
-      return OpenCL::Context::new( ptr.read_pointer )
+      ptr = FFI::MemoryPointer::new( Context )
+      error = OpenCL.clGetEventInfo(self, CONTEXT, Context.size, ptr, nil)
+      error_check(error)
+      return Context::new( ptr.read_pointer )
     end
 
     # Returns a CommandType corresponding to the type of the command associated with the Event
-    eval OpenCL.get_info("Event", :cl_command_type, "COMMAND_TYPE")
+    eval get_info("Event", :cl_command_type, "COMMAND_TYPE")
 
     # Returns a CommandExecutionStatus corresponding to the status of the command associtated with the Event
     def command_execution_status
       ptr = FFI::MemoryPointer::new( :cl_int )
       error = OpenCL.clGetEventInfo(self, COMMAND_EXECUTION_STATUS, ptr.size, ptr, nil )
-      OpenCL.error_check(error)
-      return OpenCL::CommandExecutionStatus::new( ptr.read_cl_int )
+      error_check(error)
+      return CommandExecutionStatus::new( ptr.read_cl_int )
     end
 
     ##
     # :method: reference_count()
     # Returns the reference counter of th Event
-    eval OpenCL.get_info("Event", :cl_uint, "REFERENCE_COUNT")
+    eval get_info("Event", :cl_uint, "REFERENCE_COUNT")
 
     # Returns the date the command corresponding to Event was queued
     def profiling_command_queued
        ptr = FFI::MemoryPointer::new( :cl_ulong )
-       error = OpenCL.clGetEventProfilingInfo(self, OpenCL::PROFILING_COMMAND_QUEUED, ptr.size, ptr, nil )
-       OpenCL.error_check(error)
+       error = OpenCL.clGetEventProfilingInfo(self, PROFILING_COMMAND_QUEUED, ptr.size, ptr, nil )
+       error_check(error)
        return ptr.read_cl_ulong
     end
 
     # Returns the date the command corresponding to Event was submited
     def profiling_command_submit
        ptr = FFI::MemoryPointer::new( :cl_ulong )
-       error = OpenCL.clGetEventProfilingInfo(self, OpenCL::PROFILING_COMMAND_SUBMIT, ptr.size, ptr, nil )
-       OpenCL.error_check(error)
+       error = OpenCL.clGetEventProfilingInfo(self, PROFILING_COMMAND_SUBMIT, ptr.size, ptr, nil )
+       error_check(error)
        return ptr.read_cl_ulong
     end
 
     # Returns the date the command corresponding to Event started
     def profiling_command_start
        ptr = FFI::MemoryPointer::new( :cl_ulong )
-       error = OpenCL.clGetEventProfilingInfo(self, OpenCL::PROFILING_COMMAND_START, ptr.size, ptr, nil )
-       OpenCL.error_check(error)
+       error = OpenCL.clGetEventProfilingInfo(self, PROFILING_COMMAND_START, ptr.size, ptr, nil )
+       error_check(error)
        return ptr.read_cl_ulong
     end
 
     # Returns the date the command corresponding to Event ended
     def profiling_command_end
        ptr = FFI::MemoryPointer::new( :cl_ulong )
-       error = OpenCL.clGetEventProfilingInfo(self, OpenCL::PROFILING_COMMAND_END, ptr.size, ptr, nil )
-       OpenCL.error_check(error)
+       error = OpenCL.clGetEventProfilingInfo(self, PROFILING_COMMAND_END, ptr.size, ptr, nil )
+       error_check(error)
        return ptr.read_cl_ulong
     end
 

data/lib/opencl_ruby_ffi/Image.rb

@@ -199,7 +199,6 @@ module OpenCL
   # Maps the cl_mem OpenCL objects of type CL_MEM_OBJECT_IMAGE*
   class Image
 
-
     ##
     # :method: element_size
     # Returns the element_size of the Image
@@ -228,7 +227,7 @@ module OpenCL
     # :method: array_size
     # Returns the array_size of the Image
     %w( ELEMENT_SIZE ROW_PITCH SLICE_PITCH WIDTH HEIGHT DEPTH ARRAY_SIZE ).each { |prop|
-      eval OpenCL.get_info("Image", :size_t, prop)
+      eval get_info("Image", :size_t, prop)
     }
 
     ##
@@ -239,29 +238,29 @@ module OpenCL
     # :method: num_samples
     # Returns the num_samples of the Image
     %w( NUM_MIP_LEVELS NUM_SAMPLES ).each { |prop|
-      eval OpenCL.get_info("Image", :cl_uint, prop)
+      eval get_info("Image", :cl_uint, prop)
     }
 
     # Returns the ImageDesc corresponding to the Image
     def desc
-      return OpenCL::ImageDesc::new( self.type, self.width, self.height, self.depth, self.array_size, self.row_pitch, self.slice_pitch, self.num_mip_levels, self.num_samples, self.buffer )
+      return ImageDesc::new( self.type, self.width, self.height, self.depth, self.array_size, self.row_pitch, self.slice_pitch, self.num_mip_levels, self.num_samples, self.buffer )
     end
 
     # Returns the ImageFormat corresponding to the image
     def format
-      image_format = FFI::MemoryPointer::new( OpenCL::ImageFormat )
+      image_format = FFI::MemoryPointer::new( ImageFormat )
       error = OpenCL.clGetImageInfo( self, FORMAT, image_format.size, image_format, nil)
-      OpenCL.error_check(error)
-      return OpenCL::ImageFormat::from_pointer( image_format )
+      error_check(error)
+      return ImageFormat::from_pointer( image_format )
     end
 
     # Returns the associated Buffer if any, nil otherwise
     def buffer
-      ptr = FFI::MemoryPointer::new( OpenCL::Buffer )
-      error = OpenCL.clGetImageInfo(self,  BUFFER, OpenCL::Buffer.size, ptr, nil)
-      OpenCL.error_check(error)
+      ptr = FFI::MemoryPointer::new( Buffer )
+      error = OpenCL.clGetImageInfo(self,  BUFFER, Buffer.size, ptr, nil)
+      error_check(error)
       return nil if ptr.null?
-      return OpenCL::Buffer::new(ptr.read_pointer)
+      return Buffer::new(ptr.read_pointer)
     end
 
   end

data/lib/opencl_ruby_ffi/Kernel.rb

@@ -37,9 +37,19 @@ module OpenCL
 
   # Maps the cl_kernel object
   class Kernel
+    include InnerInterface
+
+    class << self
+      include InnerGenerator
+    end
 
     # Maps the logical cl arg object
     class Arg
+      include InnerInterface
+ 
+      class << self
+        include InnerGenerator
+      end
       # Returns the index of the Arg in the list
       attr_reader :index
       # Returns the Kernel this Arg belongs to
@@ -53,58 +63,58 @@ 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
+        error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
         ptr = FFI::MemoryPointer::new( :cl_kernel_arg_address_qualifier )
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, ADDRESS_QUALIFIER, ptr.size, ptr, nil)
-        OpenCL.error_check(error)
+        error_check(error)
         return AddressQualifier::new( ptr.read_cl_kernel_arg_address_qualifier )
       end
 
       # Returns an AccessQualifier corresponding to the Arg
       def access_qualifier
-        OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
+        error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
         ptr = FFI::MemoryPointer::new( :cl_kernel_arg_access_qualifier )
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, ACCESS_QUALIFIER, ptr.size, ptr, nil)
-        OpenCL.error_check(error)
+        error_check(error)
         return AccessQualifier::new( ptr.read_cl_kernel_arg_access_qualifier )
       end
 
       # Returns a TypeQualifier corresponding to the Arg
       def type_qualifier
-        OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
+        error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
         ptr = FFI::MemoryPointer::new( :cl_kernel_arg_type_qualifier )
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_QUALIFIER, ptr.size, ptr, nil)
-        OpenCL.error_check(error)
+        error_check(error)
         return TypeQualifier::new( ptr.read_cl_kernel_arg_type_qualifier )
       end
 
       # 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
+        error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
         ptr1 = FFI::MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_NAME, 0, nil, ptr1)
-        OpenCL.error_check(error)
+        error_check(error)
         ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_NAME, ptr1.read_size_t, ptr2, nil)
-        OpenCL.error_check(error)
+        error_check(error)
         return ptr2.read_string
       end
 
       # Returns a String corresponding to the Arg name
       def name
-        OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
+        error_check(INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
         ptr1 = FFI::MemoryPointer::new( :size_t, 1)
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, NAME, 0, nil, ptr1)
-        OpenCL.error_check(error)
+        error_check(error)
         ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
         error = OpenCL.clGetKernelArgInfo(@kernel, @index, NAME, ptr1.read_size_t, ptr2, nil)
-        OpenCL.error_check(error)
+        error_check(error)
         return ptr2.read_string
       end
 
       # Sets this Arg to value. The size of value can be specified.
       def set(value, size = nil)
-        if value.class == OpenCL::SVMPointer and @kernel.context.platform.version_number >= 2.0 then
+        if value.class == 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)
@@ -125,24 +135,24 @@ module OpenCL
 
     # 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
+      error_check(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, EXEC_INFO_SVM_PTRS, pt.size, pt)
-      OpenCL.error_check(error)
+      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
+      error_check(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, EXEC_INFO_SVM_FINE_GRAIN_SYSTEL, pt.size, pt)
-      OpenCL.error_check(error)
+      error_check(error)
       return self
     end
 
@@ -154,7 +164,7 @@ module OpenCL
     # :method: attributes()
     # returns a String containing the attributes qualifier used at kernel definition
     %w( FUNCTION_NAME ATTRIBUTES ).each { |prop|
-      eval OpenCL.get_info("Kernel", :string, prop)
+      eval get_info("Kernel", :string, prop)
     }
 
     alias name function_name
@@ -167,23 +177,23 @@ module OpenCL
     # :method: reference_count
     # Returns the reference counter for the Kernel
     %w( NUM_ARGS REFERENCE_COUNT ).each { |prop|
-      eval OpenCL.get_info("Kernel", :cl_uint, prop)
+      eval get_info("Kernel", :cl_uint, prop)
     }
 
     # Returns the Context the Kernel is associated with
     def context
       ptr = FFI::MemoryPointer::new( Context )
       error = OpenCL.clGetKernelInfo(self, CONTEXT, Context.size, ptr, nil)
-      OpenCL.error_check(error)
-      return OpenCL::Context::new( ptr.read_pointer )
+      error_check(error)
+      return Context::new( ptr.read_pointer )
     end
 
     # Returns the Program the Kernel was created from
     def program
       ptr = FFI::MemoryPointer::new( Program )
       error = OpenCL.clGetKernelInfo(self, PROGRAM, Program.size, ptr, nil)
-      OpenCL.error_check(error)
-      return OpenCL::Program::new(ptr.read_pointer)
+      error_check(error)
+      return Program::new(ptr.read_pointer)
     end
 
     # Set the index th argument of the Kernel to value. The size of value can be specified.
@@ -199,15 +209,15 @@ module OpenCL
     # 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
-      OpenCL.error_check(OpenCL::INVALID_KERNEL_ARGS) if args.length < n
-      OpenCL.error_check(OpenCL::INVALID_KERNEL_ARGS) if args.length > n + 1
+      error_check(INVALID_KERNEL_ARGS) if args.length < n
+      error_check(INVALID_KERNEL_ARGS) if args.length > n + 1
       if args.length == n + 1
         options = args.last
       else
         options = {}
       end
       n.times { |i|
-        if args[i].class == OpenCL::SVMPointer and self.context.platform.version_number >= 2.0 then
+        if args[i].class == 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])