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 =

:stopdoc:

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



49
50
51
52
 
# File 'lib/opencl_ruby_ffi/Kernel.rb', line 49

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

Instance Attribute Details

#index ⇒ Object (readonly)

Returns the index of the Arg in the list



44
45
46
 
# File 'lib/opencl_ruby_ffi/Kernel.rb', line 44

def index
  @index
end

#kernel ⇒ Object (readonly)

Returns the Kernel this Arg belongs to



46
47
48
 
# File 'lib/opencl_ruby_ffi/Kernel.rb', line 46

def kernel
  @kernel
end

Instance Method Details

#access_qualifier ⇒ Object

Returns an AccessQualifier corresponding to the Arg



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

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 )
  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 )
end

#address_qualifier ⇒ Object

Returns an AddressQualifier corresponding to the Arg



55
56
57
58
59
60
61
 
# File 'lib/opencl_ruby_ffi/Kernel.rb', line 55

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 )
  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 )
end

#name ⇒ Object

Returns a String corresponding to the Arg name



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

def name
  OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
  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 )
  error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::NAME, ptr1.read_size_t, ptr2, nil)
  OpenCL.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.



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

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

#type_name ⇒ Object

Returns a String corresponding to the Arg type name



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

def type_name
  OpenCL.error_check(OpenCL::INVALID_OPERATION) if @kernel.context.platform.version_number < 1.2
  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 )
  error = OpenCL.clGetKernelArgInfo(@kernel, @index, OpenCL::Kernel::Arg::TYPE_NAME, ptr1.read_size_t, ptr2, nil)
  OpenCL.error_check(error)
  return ptr2.read_string
end

#type_qualifier ⇒ Object

Returns a TypeQualifier corresponding to the Arg



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

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 )
  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 )
end