opencl/clwrap

Search:
Group by:

OpenCL wrapper for Nimrod. For more convenient error checking you can use the 'check' template that turns TClResult into an exception.

Types

EOpenCL = object of IOError
exception raised by 'check' 
Pcommand_queue = ptr T_cl_command_queue
Pcontext = ptr T_cl_context
Pdevice_id = ptr T_cl_device_id
Pevent = ptr T_cl_event
Pkernel = ptr T_cl_kernel
Pmem = ptr T_cl_mem
Pplatform_id = ptr T_cl_platform_id
Pprogram = ptr T_cl_program
Psampler = ptr T_cl_sampler
Taddressing_mode = uint32
Tbitfield = uint64
Tbool = uint32
Tbuffer_region = object
  origin*: int
  size*: int
Tbuild_status = int32
Tchannel_order = uint32
Tchannel_type = uint32
TClResult {.size: 4.} = enum
  INVALID_DEVICE_PARTITION_COUNT = -68, INVALID_LINKER_OPTIONS = -67,
  INVALID_COMPILER_OPTIONS = -66, INVALID_IMAGE_DESCRIPTOR = -65,
  INVALID_PROPERTY = -64, INVALID_GLOBAL_WORK_SIZE = -63,
  INVALID_MIP_LEVEL = -62, INVALID_BUFFER_SIZE = -61, INVALID_GL_OBJECT = -60,
  INVALID_OPERATION = -59, INVALID_EVENT = -58, INVALID_EVENT_WAIT_LIST = -57,
  INVALID_GLOBAL_OFFSET = -56, INVALID_WORK_ITEM_SIZE = -55,
  INVALID_WORK_GROUP_SIZE = -54, INVALID_WORK_DIMENSION = -53,
  INVALID_KERNEL_ARGS = -52, INVALID_ARG_SIZE = -51, INVALID_ARG_VALUE = -50,
  INVALID_ARG_INDEX = -49, INVALID_KERNEL = -48,
  INVALID_KERNEL_DEFINITION = -47, INVALID_KERNEL_NAME = -46,
  INVALID_PROGRAM_EXECUTABLE = -45, INVALID_PROGRAM = -44,
  INVALID_BUILD_OPTIONS = -43, INVALID_BINARY = -42, INVALID_SAMPLER = -41,
  INVALID_IMAGE_SIZE = -40, INVALID_IMAGE_FORMAT_DESCRIPTOR = -39,
  INVALID_MEM_OBJECT = -38, INVALID_HOST_PTR = -37, INVALID_COMMAND_QUEUE = -36,
  INVALID_QUEUE_PROPERTIES = -35, INVALID_CONTEXT = -34, INVALID_DEVICE = -33,
  INVALID_PLATFORM = -32, INVALID_DEVICE_TYPE = -31, INVALID_VALUE = -30,
  KERNEL_ARG_INFO_NOT_AVAILABLE = -19, DEVICE_PARTITION_FAILED = -18,
  LINK_PROGRAM_FAILURE = -17, LINKER_NOT_AVAILABLE = -16,
  COMPILE_PROGRAM_FAILURE = -15,
  EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST = -14,
  MISALIGNED_SUB_BUFFER_OFFSET = -13, MAP_FAILURE = -12,
  BUILD_PROGRAM_FAILURE = -11, IMAGE_FORMAT_NOT_SUPPORTED = -10,
  IMAGE_FORMAT_MISMATCH = -9, MEM_COPY_OVERLAP = -8,
  PROFILING_INFO_NOT_AVAILABLE = -7, OUT_OF_HOST_MEMORY = -6,
  OUT_OF_RESOURCES = -5, MEM_OBJECT_ALLOCATION_FAILURE = -4,
  COMPILER_NOT_AVAILABLE = -3, DEVICE_NOT_AVAILABLE = -2, DEVICE_NOT_FOUND = -1,
  SUCCESS = 0
Tcommand_type = uint32
Tcontext_info = uint32
TCreateContextCb = proc (a2: cstring; a3: pointer; a4: int; a5: pointer) {.
    stdcall.}
Tdevice_info = uint32
TDeviceType = distinct int64
Tevent_info = uint32
TEventCb = proc (a2: Pevent; a3: int32; a4: pointer) {.stdcall.}
Tfilter_mode = uint32
Timage_desc = object
  image_type*: Tmem_object_type
  image_width*: int
  image_height*: int
  image_depth*: int
  image_array_size*: int
  image_row_pitch*: int
  image_slice_pitch*: int
  num_mip_levels*: uint32
  num_samples*: uint32
  buffer*: Pmem
Timage_format = object
  image_channel_order*: Tchannel_order
  image_channel_data_type*: Tchannel_type
Timage_info = uint32
Tkernel_arg_info = uint32
Tkernel_info = uint32
Tmem_info = uint32
Tmem_object_type = uint32
TMemObjectDestructorCb = proc (memobj: Pmem; user_data: pointer) {.stdcall.}
Tplatform_info = uint32
Tprofiling_info {.size: 4.} = enum
  PROFILING_COMMAND_QUEUED = 4736, PROFILING_COMMAND_SUBMIT = 4737,
  PROFILING_COMMAND_START = 4738, PROFILING_COMMAND_END = 4739
Tprogram_info = uint32
TProgramCb = proc (program: Pprogram; user_data: pointer) {.stdcall.}
Tsampler_info = uint32
TUserCb = proc (a2: pointer) {.stdcall.}

Consts

ADDRESS_CLAMP = 0x00001132
ADDRESS_CLAMP_TO_EDGE = 0x00001131
ADDRESS_NONE = 0x00001130
ADDRESS_REPEAT = 0x00001133
BLOCKING = 1
BUILD_NONE = -1
CL_A = 0x000010B1
CL_ARGB = 0x000010B7
CL_BGRA = 0x000010B6
CL_FALSE = 0
CL_FLOAT = 0x000010DE
CL_HALF_FLOAT = 0x000010DD
CL_R = 0x000010B0
CL_RA = 0x000010B3
CL_RG = 0x000010B2
CL_RGB = 0x000010B4
CL_RGBA = 0x000010B5
CL_RGBx = 0x000010BC
CL_RGx = 0x000010BB
CL_Rx = 0x000010BA
CL_SIGNED_INT8 = 0x000010D7
CL_SIGNED_INT16 = 0x000010D8
CL_SIGNED_INT32 = 0x000010D9
CL_SNORM_INT8 = 0x000010D0
CL_SNORM_INT16 = 0x000010D1
CL_TRUE = 1
CL_UNORM_INT8 = 0x000010D2
CL_UNORM_INT16 = 0x000010D3
CL_UNORM_INT24 = 0x000010DF
CL_UNORM_INT_101010 = 0x000010D6
CL_UNORM_SHORT_555 = 0x000010D5
CL_UNORM_SHORT_565 = 0x000010D4
CL_UNSIGNED_INT8 = 0x000010DA
CL_UNSIGNED_INT16 = 0x000010DB
CL_UNSIGNED_INT32 = 0x000010DC
COMMAND_BARRIER = 0x00001205
COMMAND_COPY_BUFFER = 0x000011F5
COMMAND_COPY_IMAGE = 0x000011F8
COMMAND_FILL_BUFFER = 0x00001207
COMMAND_FILL_IMAGE = 0x00001208
COMMAND_MAP_BUFFER = 0x000011FB
COMMAND_MAP_IMAGE = 0x000011FC
COMMAND_MARKER = 0x000011FE
COMMAND_NATIVE_KERNEL = 0x000011F2
COMMAND_NDRANGE_KERNEL = 0x000011F0
COMMAND_READ_BUFFER = 0x000011F3
COMMAND_READ_IMAGE = 0x000011F6
COMMAND_TASK = 0x000011F1
COMMAND_USER = 0x00001204
COMMAND_WRITE_BUFFER = 0x000011F4
COMMAND_WRITE_IMAGE = 0x000011F7
COMPLETE = 0x00000000
CONTEXT_DEVICES = 0x00001081
CONTEXT_NUM_DEVICES = 0x00001083
CONTEXT_PLATFORM = 0x00001084
CONTEXT_PROPERTIES = 0x00001082
DEPTH = 0x000010BD
DEPTH_STENCIL = 0x000010BE
DEVICE_ADDRESS_BITS = 0x0000100D
DEVICE_AVAILABLE = 0x00001027
DEVICE_ENDIAN_LITTLE = 0x00001026
DEVICE_EXTENSIONS = 0x00001030
DEVICE_GLOBAL_MEM_SIZE = 0x0000101F
DEVICE_IMAGE_SUPPORT = 0x00001016
DEVICE_LOCAL_MEM_SIZE = 0x00001023
DEVICE_LOCAL_MEM_TYPE = 0x00001022
DEVICE_MAX_SAMPLERS = 0x00001018
DEVICE_NAME = 0x0000102B
DEVICE_PARENT_DEVICE = 0x00001042
DEVICE_PARTITION_TYPE = 0x00001046
DEVICE_PLATFORM = 0x00001031
DEVICE_PROFILE = 0x0000102E
DEVICE_REFERENCE_COUNT = 0x00001047
DEVICE_TYPE = 0x00001000
DEVICE_TYPE_ALL = 4294967295'i64
DEVICE_TYPE_CPU = 2'i64
DEVICE_TYPE_GPU = 4'i64
DEVICE_VENDOR = 0x0000102C
DEVICE_VENDOR_ID = 0x00001001
DEVICE_VERSION = 0x0000102F
DRIVER_VERSION = 0x0000102D
EVENT_COMMAND_QUEUE = 0x000011D0
EVENT_COMMAND_TYPE = 0x000011D1
EVENT_CONTEXT = 0x000011D4
EVENT_REFERENCE_COUNT = 0x000011D2
FILTER_LINEAR = 0x00001141
FILTER_NEAREST = 0x00001140
FP_DENORM = 1
FP_FMA = 32
GLOBAL = 0x00000002
IMAGE_ARRAY_SIZE = 0x00001117
IMAGE_BUFFER = 0x00001118
IMAGE_DEPTH = 0x00001116
IMAGE_ELEMENT_SIZE = 0x00001111
IMAGE_FORMAT = 0x00001110
IMAGE_HEIGHT = 0x00001115
IMAGE_NUM_MIP_LEVELS = 0x00001119
IMAGE_NUM_SAMPLES = 0x0000111A
IMAGE_ROW_PITCH = 0x00001112
IMAGE_SLICE_PITCH = 0x00001113
IMAGE_WIDTH = 0x00001114
INTENSITY = 0x000010B8
KERNEL_ARG_ACCESS_NONE = 0x000011A3
KERNEL_ARG_NAME = 0x0000119A
KERNEL_ARG_TYPE_NAME = 0x00001198
KERNEL_ATTRIBUTES = 0x00001195
KERNEL_CONTEXT = 0x00001193
KERNEL_FUNCTION_NAME = 0x00001190
KERNEL_LOCAL_MEM_SIZE = 0x000011B2
KERNEL_NUM_ARGS = 0x00001191
KERNEL_PROGRAM = 0x00001194
KERNEL_REFERENCE_COUNT = 0x00001192
KERNEL_WORK_GROUP_SIZE = 0x000011B0
LOCAL = 0x00000001
LUMINANCE = 0x000010B9
MAP_READ = 1
MAP_WRITE = 2
MEM_CONTEXT = 0x00001106
MEM_FLAGS = 0x00001101
MEM_HOST_PTR = 0x00001103
MEM_MAP_COUNT = 0x00001104
MEM_OBJECT_BUFFER = 0x000010F0
MEM_OBJECT_IMAGE1D = 0x000010F4
MEM_OBJECT_IMAGE2D = 0x000010F1
MEM_OBJECT_IMAGE3D = 0x000010F2
MEM_OFFSET = 0x00001108
MEM_REFERENCE_COUNT = 0x00001105
MEM_SIZE = 0x00001102
MEM_TYPE = 0x00001100
MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED = 2
NONE = 0x00000000
PLATFORM_EXTENSIONS = 0x00000904
PLATFORM_NAME = 0x00000902
PLATFORM_PROFILE = 0x00000900
PLATFORM_VENDOR = 0x00000903
PLATFORM_VERSION = 0x00000901
PROGRAM_BINARIES = 0x00001166
PROGRAM_BINARY_SIZES = 0x00001165
PROGRAM_BINARY_TYPE = 0x00001184
PROGRAM_BUILD_LOG = 0x00001183
PROGRAM_BUILD_OPTIONS = 0x00001182
PROGRAM_BUILD_STATUS = 0x00001181
PROGRAM_CONTEXT = 0x00001161
PROGRAM_DEVICES = 0x00001163
PROGRAM_KERNEL_NAMES = 0x00001168
PROGRAM_NUM_DEVICES = 0x00001162
PROGRAM_NUM_KERNELS = 0x00001167
PROGRAM_SOURCE = 0x00001164
QUEUE_CONTEXT = 0x00001090
QUEUE_DEVICE = 0x00001091
QUEUE_PROPERTIES = 0x00001093
QUEUE_REFERENCE_COUNT = 0x00001092
QUEUED = 0x00000003
READ_ONLY_CACHE = 0x00000001
READ_WRITE_CACHE = 0x00000002
RUNNING = 0x00000001
SAMPLER_CONTEXT = 0x00001151
SAMPLER_FILTER_MODE = 0x00001154
SUBMITTED = 0x00000002

Procs

proc buildProgram(program: Pprogram; num_devices: uint32;
                  device_list: ptr Pdevice_id; options: cstring;
                  pfn_notify: TProgramCb; user_data: pointer): TClResult {.
    importc: "clBuildProgram", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc compileProgram(program: Pprogram; num_devices: uint32;
                    device_list: ptr Pdevice_id; options: cstring;
                    num_input_headers: uint32; input_headers: ptr Pprogram;
                    header_include_names: cstringArray; pfn_notify: TProgramCb;
                    user_data: pointer): TClResult {.
    importc: "clCompileProgram", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc createBuffer(context: Pcontext; flags: Tmem_flags; size: int;
                  host_ptr: pointer; errcode_ret: ptr TClResult): Pmem {.
    importc: "clCreateBuffer", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc createCommandQueue(context: Pcontext; device: Pdevice_id;
                        properties: Tcommand_queue_properties;
                        errcode_ret: ptr TClResult): Pcommand_queue {.
    importc: "clCreateCommandQueue", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc createContext(properties: ptr Tcontext_properties; num_devices: uint32;
                   devices: ptr Pdevice_id; pfn_notify: TCreateContextCb;
                   user_data: pointer; errcode_ret: ptr TClResult): Pcontext {.
    importc: "clCreateContext", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc createContextFromType(properties: ptr Tcontext_properties;
                           device_type: TDeviceType;
                           pfn_notify: TCreateContextCb; user_data: pointer;
                           errcode_ret: ptr TClResult): Pcontext {.
    importc: "clCreateContextFromType", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc createImage(context: Pcontext; flags: Tmem_flags;
                 image_format: ptr Timage_format; image_desc: ptr Timage_desc;
                 host_ptr: pointer; errcode_ret: ptr TClResult): Pmem {.
    importc: "clCreateImage", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc createImage2D(context: Pcontext; flags: Tmem_flags;
                   image_format: ptr Timage_format; image_width: int;
                   image_height: int; image_row_pitch: int; host_ptr: pointer;
                   errcode_ret: ptr TClResult): Pmem {.
    importc: "clCreateImage2D", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc createImage3D(context: Pcontext; flags: Tmem_flags;
                   image_format: ptr Timage_format; image_width: int;
                   image_height: int; image_depth: int; image_row_pitch: int;
                   image_slice_pitch: int; host_ptr: pointer;
                   errcode_ret: ptr TClResult): Pmem {.
    importc: "clCreateImage3D", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc createKernel(program: Pprogram; kernel_name: cstring;
                  errcode_ret: ptr TClResult): Pkernel {.
    importc: "clCreateKernel", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc createKernelsInProgram(program: Pprogram; num_kernels: uint32;
                            kernels: ptr Pkernel; num_kernels_ret: ptr uint32): TClResult {.
    importc: "clCreateKernelsInProgram", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc createProgramWithBinary(context: Pcontext; num_devices: uint32;
                             device_list: ptr Pdevice_id; lengths: ptr int;
                             binaries: ptr ptr uint8; binary_status: ptr int32;
                             errcode_ret: ptr TClResult): Pprogram {.
    importc: "clCreateProgramWithBinary", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc createProgramWithBuiltInKernels(context: Pcontext; num_devices: uint32;
                                     device_list: ptr Pdevice_id;
                                     kernel_names: cstring;
                                     errcode_ret: ptr TClResult): Pprogram {.
    importc: "clCreateProgramWithBuiltInKernels", stdcall,
    dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc createProgramWithSource(context: Pcontext; count: uint32;
                             strings: cstringArray; lengths: ptr int;
                             errcode_ret: ptr TClResult): Pprogram {.
    importc: "clCreateProgramWithSource", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc createSampler(context: Pcontext; normalized_coords: Tbool;
                   addressing_mode: Taddressing_mode; filter_mode: Tfilter_mode;
                   errcode_ret: ptr TClResult): Psampler {.
    importc: "clCreateSampler", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc createSubBuffer(buffer: Pmem; flags: Tmem_flags;
                     buffer_create_type: Tbuffer_create_type;
                     buffer_create_info: pointer; errcode_ret: ptr TClResult): Pmem {.
    importc: "clCreateSubBuffer", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc createSubDevices(in_device: Pdevice_id;
                      properties: ptr Tdevice_partition_property;
                      num_devices: uint32; out_devices: ptr Pdevice_id;
                      num_devices_ret: ptr uint32): TClResult {.
    importc: "clCreateSubDevices", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc createUserEvent(context: Pcontext; errcode_ret: ptr TClResult): Pevent {.
    importc: "clCreateUserEvent", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc enqueueBarrier(command_queue: Pcommand_queue): TClResult {.
    importc: "clEnqueueBarrier", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc enqueueBarrierWithWaitList(command_queue: Pcommand_queue;
                                num_events_in_wait_list: uint32;
                                event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueBarrierWithWaitList", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc enqueueCopyBuffer(command_queue: Pcommand_queue; src_buffer: Pmem;
                       dst_buffer: Pmem; src_offset: int; dst_offset: int;
                       size: int; num_events_in_wait_list: uint32;
                       event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueCopyBuffer", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc enqueueCopyBufferRect(command_queue: Pcommand_queue; src_buffer: Pmem;
                           dst_buffer: Pmem; src_origin: ptr int;
                           dst_origin: ptr int; region: ptr int;
                           src_row_pitch: int; src_slice_pitch: int;
                           dst_row_pitch: int; dst_slice_pitch: int;
                           num_events_in_wait_list: uint32;
                           event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueCopyBufferRect", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc enqueueCopyBufferToImage(command_queue: Pcommand_queue; src_buffer: Pmem;
                              dst_image: Pmem; src_offset: int;
                              dst_origin: array[3, ptr int];
                              region: array[3, ptr int];
                              num_events_in_wait_list: uint32;
                              event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueCopyBufferToImage", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc enqueueCopyImage(command_queue: Pcommand_queue; src_image: Pmem;
                      dst_image: Pmem; src_origin: array[3, ptr int];
                      dst_origin: array[3, ptr int]; region: array[3, ptr int];
                      num_events_in_wait_list: uint32;
                      event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueCopyImage", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc enqueueCopyImageToBuffer(command_queue: Pcommand_queue; src_image: Pmem;
                              dst_buffer: Pmem; src_origin: array[3, ptr int];
                              region: array[3, ptr int]; dst_offset: int;
                              num_events_in_wait_list: uint32;
                              event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueCopyImageToBuffer", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc enqueueFillBuffer(command_queue: Pcommand_queue; buffer: Pmem;
                       pattern: pointer; pattern_size: int; offset: int;
                       size: int; num_events_in_wait_list: uint32;
                       event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueFillBuffer", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc enqueueFillImage(command_queue: Pcommand_queue; image: Pmem;
                      fill_color: pointer; origin: array[3, ptr int];
                      region: array[3, ptr int];
                      num_events_in_wait_list: uint32;
                      event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueFillImage", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc enqueueMapBuffer(command_queue: Pcommand_queue; buffer: Pmem;
                      blocking_map: Tbool; map_flags: Tmap_flags; offset: int;
                      size: int; num_events_in_wait_list: uint32;
                      event_wait_list: ptr Pevent; event: ptr Pevent;
                      errcode_ret: ptr TClResult): pointer {.
    importc: "clEnqueueMapBuffer", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc enqueueMapImage(command_queue: Pcommand_queue; image: Pmem;
                     blocking_map: Tbool; map_flags: Tmap_flags;
                     origin: array[3, ptr int]; region: array[3, ptr int];
                     image_row_pitch: ptr int; image_slice_pitch: ptr int;
                     num_events_in_wait_list: uint32;
                     event_wait_list: ptr Pevent; event: ptr Pevent;
                     errcode_ret: ptr TClResult): pointer {.
    importc: "clEnqueueMapImage", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc enqueueMarker(command_queue: Pcommand_queue; event: ptr Pevent): TClResult {.
    importc: "clEnqueueMarker", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc enqueueMarkerWithWaitList(command_queue: Pcommand_queue;
                               num_events_in_wait_list: uint32;
                               event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueMarkerWithWaitList", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc enqueueMigrateMemObjects(command_queue: Pcommand_queue;
                              num_mem_objects: uint32; mem_objects: ptr Pmem;
                              flags: Tmem_migration_flags;
                              num_events_in_wait_list: uint32;
                              event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueMigrateMemObjects", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc enqueueNativeKernel(command_queue: Pcommand_queue; user_func: TUserCb;
                         args: pointer; cb_args: int; num_mem_objects: uint32;
                         mem_list: ptr Pmem; args_mem_loc: ptr pointer;
                         num_events_in_wait_list: uint32;
                         event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueNativeKernel", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc enqueueNDRangeKernel(command_queue: Pcommand_queue; kernel: Pkernel;
                          work_dim: uint32; global_work_offset: ptr int;
                          global_work_size: ptr int; local_work_size: ptr int;
                          num_events_in_wait_list: uint32;
                          event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueNDRangeKernel", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc enqueueReadBuffer(command_queue: Pcommand_queue; buffer: Pmem;
                       blocking_read: Tbool; offset: int; size: int;
                       theptr: pointer; num_events_in_wait_list: uint32;
                       event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueReadBuffer", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc enqueueReadBufferRect(command_queue: Pcommand_queue; buffer: Pmem;
                           blocking_read: Tbool; buffer_offset: ptr int;
                           host_offset: ptr int; region: ptr int;
                           buffer_row_pitch: int; buffer_slice_pitch: int;
                           host_row_pitch: int; host_slice_pitch: int;
                           theptr: pointer; num_events_in_wait_list: uint32;
                           event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueReadBufferRect", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc enqueueReadImage(command_queue: Pcommand_queue; image: Pmem;
                      blocking_read: Tbool; origin: array[3, ptr int];
                      region: array[3, ptr int]; row_pitch: int;
                      slice_pitch: int; theptr: pointer;
                      num_events_in_wait_list: uint32;
                      event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueReadImage", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc enqueueTask(command_queue: Pcommand_queue; kernel: Pkernel;
                 num_events_in_wait_list: uint32; event_wait_list: ptr Pevent;
                 event: ptr Pevent): TClResult {.importc: "clEnqueueTask",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc enqueueUnmapMemObject(command_queue: Pcommand_queue; memobj: Pmem;
                           mapped_ptr: pointer; num_events_in_wait_list: uint32;
                           event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueUnmapMemObject", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc enqueueWaitForEvents(command_queue: Pcommand_queue; num_events: uint32;
                          event_list: ptr Pevent): TClResult {.
    importc: "clEnqueueWaitForEvents", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc enqueueWriteBuffer(command_queue: Pcommand_queue; buffer: Pmem;
                        blocking_write: Tbool; offset: int; size: int;
                        theptr: pointer; num_events_in_wait_list: uint32;
                        event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueWriteBuffer", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc enqueueWriteBufferRect(command_queue: Pcommand_queue; buffer: Pmem;
                            blocking_write: Tbool; buffer_offset: ptr int;
                            host_offset: ptr int; region: ptr int;
                            buffer_row_pitch: int; buffer_slice_pitch: int;
                            host_row_pitch: int; host_slice_pitch: int;
                            theptr: pointer; num_events_in_wait_list: uint32;
                            event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueWriteBufferRect", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc enqueueWriteImage(command_queue: Pcommand_queue; image: Pmem;
                       blocking_write: Tbool; origin: array[3, ptr int];
                       region: array[3, ptr int]; input_row_pitch: int;
                       input_slice_pitch: int; theptr: pointer;
                       num_events_in_wait_list: uint32;
                       event_wait_list: ptr Pevent; event: ptr Pevent): TClResult {.
    importc: "clEnqueueWriteImage", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc finish(command_queue: Pcommand_queue): TClResult {.importc: "clFinish",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc flush(command_queue: Pcommand_queue): TClResult {.importc: "clFlush",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc getCommandQueueInfo(command_queue: Pcommand_queue;
                         param_name: Tcommand_queue_info; param_value_size: int;
                         param_value: pointer; param_value_size_ret: ptr int): TClResult {.
    importc: "clGetCommandQueueInfo", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc getContextInfo(context: Pcontext; param_name: Tcontext_info;
                    param_value_size: int; param_value: pointer;
                    param_value_size_ret: ptr int): TClResult {.
    importc: "clGetContextInfo", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc getDeviceIDs(platform: Pplatform_id; device_type: TDeviceType;
                  num_entries: uint32; devices: ptr Pdevice_id;
                  num_devices: ptr uint32): TClResult {.
    importc: "clGetDeviceIDs", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc getDeviceInfo(device: Pdevice_id; param_name: Tdevice_info;
                   param_value_size: int; param_value: pointer;
                   param_value_size_ret: ptr int): TClResult {.
    importc: "clGetDeviceInfo", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc getEventInfo(event: Pevent; param_name: Tevent_info; param_value_size: int;
                  param_value: pointer; param_value_size_ret: ptr int): TClResult {.
    importc: "clGetEventInfo", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc getEventProfilingInfo(event: Pevent; param_name: Tprofiling_info;
                           param_value_size: int; param_value: pointer;
                           param_value_size_ret: ptr int): TClResult {.
    importc: "clGetEventProfilingInfo", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc getExtensionFunctionAddress(func_name: cstring): pointer {.
    importc: "clGetExtensionFunctionAddress", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc getExtensionFunctionAddressForPlatform(platform: Pplatform_id;
    func_name: cstring): pointer {.importc: "clGetExtensionFunctionAddressForPlatform",
                                   stdcall, dynlib: "libOpenCL.so", ...raises: [],
                                   tags: [], forbids: [].}
proc getImageInfo(image: Pmem; param_name: Timage_info; param_value_size: int;
                  param_value: pointer; param_value_size_ret: ptr int): TClResult {.
    importc: "clGetImageInfo", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc getKernelArgInfo(kernel: Pkernel; arg_indx: uint32;
                      param_name: Tkernel_arg_info; param_value_size: int;
                      param_value: pointer; param_value_size_ret: ptr int): TClResult {.
    importc: "clGetKernelArgInfo", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc getKernelInfo(kernel: Pkernel; param_name: Tkernel_info;
                   param_value_size: int; param_value: pointer;
                   param_value_size_ret: ptr int): TClResult {.
    importc: "clGetKernelInfo", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc getKernelWorkGroupInfo(kernel: Pkernel; device: Pdevice_id;
                            param_name: Tkernel_work_group_info;
                            param_value_size: int; param_value: pointer;
                            param_value_size_ret: ptr int): TClResult {.
    importc: "clGetKernelWorkGroupInfo", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc getMemObjectInfo(memobj: Pmem; param_name: Tmem_info;
                      param_value_size: int; param_value: pointer;
                      param_value_size_ret: ptr int): TClResult {.
    importc: "clGetMemObjectInfo", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc getPlatformIDs(num_entries: uint32; platforms: ptr Pplatform_id;
                    num_platforms: ptr uint32): TClResult {.
    importc: "clGetPlatformIDs", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc getPlatformInfo(platform: Pplatform_id; param_name: Tplatform_info;
                     param_value_size: int; param_value: pointer;
                     param_value_size_ret: ptr int): TClResult {.
    importc: "clGetPlatformInfo", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc getProgramBuildInfo(program: Pprogram; device: Pdevice_id;
                         param_name: Tprogram_build_info; param_value_size: int;
                         param_value: pointer; param_value_size_ret: ptr int): TClResult {.
    importc: "clGetProgramBuildInfo", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc getProgramInfo(program: Pprogram; param_name: Tprogram_info;
                    param_value_size: int; param_value: pointer;
                    param_value_size_ret: ptr int): TClResult {.
    importc: "clGetProgramInfo", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc getSamplerInfo(sampler: Psampler; param_name: Tsampler_info;
                    param_value_size: int; param_value: pointer;
                    param_value_size_ret: ptr int): TClResult {.
    importc: "clGetSamplerInfo", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc getSupportedImageFormats(context: Pcontext; flags: Tmem_flags;
                              image_type: Tmem_object_type; num_entries: uint32;
                              image_formats: ptr Timage_format;
                              num_image_formats: ptr uint32): TClResult {.
    importc: "clGetSupportedImageFormats", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc linkProgram(context: Pcontext; num_devices: uint32;
                 device_list: ptr Pdevice_id; options: cstring;
                 num_input_programs: uint32; input_programs: ptr Pprogram;
                 pfn_notify: TProgramCb; user_data: pointer;
                 errcode_ret: ptr TClResult): Pprogram {.
    importc: "clLinkProgram", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc raiseEOpenCL(x: TClResult) {.noinline, ...raises: [EOpenCL], tags: [],
                                  forbids: [].}
proc releaseCommandQueue(command_queue: Pcommand_queue): TClResult {.
    importc: "clReleaseCommandQueue", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc releaseContext(context: Pcontext): TClResult {.importc: "clReleaseContext",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc releaseDevice(device: Pdevice_id): TClResult {.importc: "clReleaseDevice",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc releaseEvent(event: Pevent): TClResult {.importc: "clReleaseEvent",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc releaseKernel(kernel: Pkernel): TClResult {.importc: "clReleaseKernel",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc releaseMemObject(memobj: Pmem): TClResult {.importc: "clReleaseMemObject",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc releaseProgram(program: Pprogram): TClResult {.importc: "clReleaseProgram",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc releaseSampler(sampler: Psampler): TClResult {.importc: "clReleaseSampler",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc retainCommandQueue(command_queue: Pcommand_queue): TClResult {.
    importc: "clRetainCommandQueue", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc retainContext(context: Pcontext): TClResult {.importc: "clRetainContext",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc retainDevice(device: Pdevice_id): TClResult {.importc: "clRetainDevice",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc retainEvent(event: Pevent): TClResult {.importc: "clRetainEvent", stdcall,
    dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc retainKernel(kernel: Pkernel): TClResult {.importc: "clRetainKernel",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc retainMemObject(memobj: Pmem): TClResult {.importc: "clRetainMemObject",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc retainProgram(program: Pprogram): TClResult {.importc: "clRetainProgram",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc retainSampler(sampler: Psampler): TClResult {.importc: "clRetainSampler",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc setEventCallback(event: Pevent; command_exec_callback_type: int32;
                      pfn_notify: TEventCb; user_data: pointer): TClResult {.
    importc: "clSetEventCallback", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}
proc setKernelArg(kernel: Pkernel; arg_index: uint32; arg_size: int;
                  arg_value: pointer): TClResult {.importc: "clSetKernelArg",
    stdcall, dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc setMemObjectDestructorCallback(memobj: Pmem;
                                    pfn_notify: TMemObjectDestructorCb;
                                    user_data: pointer): TClResult {.
    importc: "clSetMemObjectDestructorCallback", stdcall,
    dynlib: "libOpenCL.so", ...raises: [], tags: [], forbids: [].}
proc setUserEventStatus(event: Pevent; execution_status: int32): TClResult {.
    importc: "clSetUserEventStatus", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc unloadCompiler(): TClResult {.importc: "clUnloadCompiler", stdcall,
                                   dynlib: "libOpenCL.so", ...raises: [], tags: [],
                                   forbids: [].}
proc unloadPlatformCompiler(platform: Pplatform_id): TClResult {.
    importc: "clUnloadPlatformCompiler", stdcall, dynlib: "libOpenCL.so",
    ...raises: [], tags: [], forbids: [].}
proc waitForEvents(num_events: uint32; event_list: ptr Pevent): TClResult {.
    importc: "clWaitForEvents", stdcall, dynlib: "libOpenCL.so", ...raises: [],
    tags: [], forbids: [].}

Templates

template check(a: TClResult)

Made with Nim. Generated: 2026-02-07 07:38:44 UTC