Class: OpenCL::Kernel::Arg

Inherits:
Object
  • Object
show all
Defined in:
lib/opencl_ruby_ffi/Kernel.rb,
lib/opencl_ruby_ffi/opencl_ruby_ffi_base_gen.rb,
lib/opencl_ruby_ffi/opencl_ruby_ffi_base_gen.rb

Overview

Maps the arg logical OpenCL objects

Defined Under Namespace

Classes: AccessQualifier, AddressQualifier, TypeQualifier

Constant Summary collapse

ADDRESS_QUALIFIER = 
0x1196
ACCESS_QUALIFIER = 
0x1197
TYPE_NAME = 
0x1198
TYPE_QUALIFIER = 
0x1199
NAME = 
0x119A
ADDRESS_GLOBAL = 
0x119B
ADDRESS_LOCAL = 
0x119C
ADDRESS_CONSTANT = 
0x119D
ADDRESS_PRIVATE = 
0x119E
ACCESS_READ_ONLY = 
0x11A0
ACCESS_WRITE_ONLY = 
0x11A1
ACCESS_READ_WRITE = 
0x11A2
ACCESS_NONE = 
0x11A3
TYPE_NONE = 
0
TYPE_CONST = 
(1 << 0)
TYPE_RESTRICT = 
(1 << 1)
TYPE_VOLATILE = 
(1 << 2)
TYPE_PIPE = 
(1 << 3)

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(kernel, index) ⇒ Arg

Creates a new arg for a Kernel at index



59
60
61
62
 
# File 'lib/opencl_ruby_ffi/Kernel.rb', line 59

def initialize( kernel, index )
  @index = index
  @kernel = kernel
end

Instance Attribute Details

#index ⇒ Object (readonly)

Returns the index of the Arg in the list



54
55
56
 
# File 'lib/opencl_ruby_ffi/Kernel.rb', line 54

def index
  @index
end

#kernel ⇒ Object (readonly)

Returns the Kernel this Arg belongs to



56
57
58
 
# File 'lib/opencl_ruby_ffi/Kernel.rb', line 56

def kernel
  @kernel
end

Instance Method Details

#access_qualifier ⇒ Object

Returns an AccessQualifier corresponding to the Arg



74
75
76
77
78
79
80
 
# File 'lib/opencl_ruby_ffi/Kernel.rb', line 74

def access_qualifier
  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)
  error_check(error)
  return AccessQualifier::new( ptr.read_cl_kernel_arg_access_qualifier )
end

#address_qualifier ⇒ Object

Returns an AddressQualifier corresponding to the Arg



65
66
67
68
69
70
71
 
# File 'lib/opencl_ruby_ffi/Kernel.rb', line 65

def address_qualifier
  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)
  error_check(error)
  return AddressQualifier::new( ptr.read_cl_kernel_arg_address_qualifier )
end

#name ⇒ Object

Returns a String corresponding to the Arg name



104
105
106
107
108
109
110
111
112
113
 
# File 'lib/opencl_ruby_ffi/Kernel.rb', line 104

def name
  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)
  error_check(error)
  ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
  error = OpenCL.clGetKernelArgInfo(@kernel, @index, NAME, ptr1.read_size_t, ptr2, nil)
  error_check(error)
  return ptr2.read_string
end

#set(value, size = nil) ⇒ Object

Sets this Arg to value. The size of value can be specified.



116
117
118
119
120
121
122
 
# File 'lib/opencl_ruby_ffi/Kernel.rb', line 116

def set(value, size = nil)
  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)
  end
end

#type_name ⇒ Object

Returns a String corresponding to the Arg type name



92
93
94
95
96
97
98
99
100
101
 
# File 'lib/opencl_ruby_ffi/Kernel.rb', line 92

def type_name
  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)
  error_check(error)
  ptr2 = FFI::MemoryPointer::new( ptr1.read_size_t )
  error = OpenCL.clGetKernelArgInfo(@kernel, @index, TYPE_NAME, ptr1.read_size_t, ptr2, nil)
  error_check(error)
  return ptr2.read_string
end

#type_qualifier ⇒ Object

Returns a TypeQualifier corresponding to the Arg



83
84
85
86
87
88
89
 
# File 'lib/opencl_ruby_ffi/Kernel.rb', line 83

def type_qualifier
  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)
  error_check(error)
  return TypeQualifier::new( ptr.read_cl_kernel_arg_type_qualifier )
end