From db097e0d93bb096213806a97968f5b37255a70a6 Mon Sep 17 00:00:00 2001
From: Yichao Yu <yyc1992@gmail.com>
Date: Fri, 23 May 2014 22:14:32 -0400
Subject: [PATCH] clean up, consistent naming
---
pyopencl/_cffi.py | 4 +-
pyopencl/c_wrapper/wrap_cl_core.h | 217 ++--
pyopencl/c_wrapper/wrap_cl_gl_core.h | 19 +-
pyopencl/cffi_cl.py | 224 ++---
pyopencl/tools.py | 2 +-
src/c_wrapper/bitlog.cpp | 71 +-
src/c_wrapper/bitlog.h | 40 -
src/c_wrapper/error.h | 12 +-
src/c_wrapper/wrap_cl.cpp | 1394 ++++++++++++--------------
9 files changed, 881 insertions(+), 1102 deletions(-)
delete mode 100644 src/c_wrapper/bitlog.h
diff --git a/pyopencl/_cffi.py b/pyopencl/_cffi.py
index 8c12c497..b505369e 100644
--- a/pyopencl/_cffi.py
+++ b/pyopencl/_cffi.py
@@ -160,9 +160,9 @@ def _import_library():
_lib = _import_library()
-if _lib.pyopencl_have_gl():
+if _lib.have_gl():
_ffi.cdef(_get_wrap_header("wrap_cl_gl_core.h"))
import gc
_gc_collect = _ffi.callback('int(void)')(gc.collect)
-_lib.pyopencl_set_gc(_gc_collect)
+_lib.set_gc(_gc_collect)
diff --git a/pyopencl/c_wrapper/wrap_cl_core.h b/pyopencl/c_wrapper/wrap_cl_core.h
index 45c9a3fd..26b78dd7 100644
--- a/pyopencl/c_wrapper/wrap_cl_core.h
+++ b/pyopencl/c_wrapper/wrap_cl_core.h
@@ -1,144 +1,149 @@
-// Everything in here should have a 'pyopencl_' prefix to avoid clashing with
-// other libraries imported via CFFI.
+// Interface between C and Python
-typedef enum { KND_UNKNOWN, KND_SOURCE, KND_BINARY } program_kind_type;
+// Types
+typedef enum {
+ KND_UNKNOWN,
+ KND_SOURCE,
+ KND_BINARY
+} program_kind_type;
typedef struct {
- const char *routine;
- const char *msg;
- cl_int code;
- int other;
+ const char *routine;
+ const char *msg;
+ cl_int code;
+ int other;
} error;
typedef enum {
- CLASS_NONE,
- CLASS_PLATFORM,
- CLASS_DEVICE,
- CLASS_KERNEL,
- CLASS_CONTEXT,
- CLASS_BUFFER,
- CLASS_PROGRAM,
- CLASS_EVENT,
- CLASS_COMMAND_QUEUE,
- CLASS_GL_BUFFER,
- CLASS_GL_RENDERBUFFER,
- CLASS_IMAGE,
- CLASS_SAMPLER
+ CLASS_NONE,
+ CLASS_PLATFORM,
+ CLASS_DEVICE,
+ CLASS_KERNEL,
+ CLASS_CONTEXT,
+ CLASS_BUFFER,
+ CLASS_PROGRAM,
+ CLASS_EVENT,
+ CLASS_COMMAND_QUEUE,
+ CLASS_GL_BUFFER,
+ CLASS_GL_RENDERBUFFER,
+ CLASS_IMAGE,
+ CLASS_SAMPLER
} class_t;
-
typedef struct {
- class_t opaque_class;
- const char *type;
- void *value;
- int dontfree;
+ class_t opaque_class;
+ const char *type;
+ void *value;
+ int dontfree;
} generic_info;
-int pyopencl_get_cl_version();
+// Generic functions
+int get_cl_version();
+void free_pointer(void*);
+void free_pointer_array(void**, uint32_t size);
+void set_gc(int (*func)());
+int have_gl();
+
+unsigned bitlog2(unsigned long v);
+void populate_constants(void(*add)(const char*, const char*, long value));
+// Platform
error *get_platforms(clobj_t **ptr_platforms, uint32_t *num_platforms);
error *platform__get_devices(clobj_t platform, clobj_t **ptr_devices,
uint32_t *num_devices, cl_device_type devtype);
-error *_create_context(clobj_t *ctx, const cl_context_properties *properties,
- cl_uint num_devices, const clobj_t *ptr_devices);
-error *_create_command_queue(clobj_t *queue, clobj_t context, clobj_t device,
- cl_command_queue_properties properties);
-error *_create_buffer(clobj_t *buffer, clobj_t context, cl_mem_flags flags,
- size_t size, void *hostbuf);
-error *_create_program_with_source(clobj_t *program, clobj_t context,
- const char *src);
-error *_create_program_with_binary(clobj_t *program, clobj_t context,
- cl_uint num_devices, const clobj_t *devices,
- cl_uint num_binaries, char **binaries,
- size_t *binary_sizes);
+// Context
+error *create_context(clobj_t *ctx, const cl_context_properties *properties,
+ cl_uint num_devices, const clobj_t *ptr_devices);
+error *context__get_supported_image_formats(clobj_t context, cl_mem_flags flags,
+ cl_mem_object_type image_type,
+ generic_info *out);
+// Command Queue
+error *create_command_queue(clobj_t *queue, clobj_t context, clobj_t device,
+ cl_command_queue_properties properties);
+error *command_queue__finish(clobj_t queue);
+error *command_queue__flush(clobj_t queue);
+// Buffer
+error *create_buffer(clobj_t *buffer, clobj_t context, cl_mem_flags flags,
+ size_t size, void *hostbuf);
+// Memory Object
+error *memory_object__release(clobj_t obj);
+// Program
+error *create_program_with_source(clobj_t *program, clobj_t context,
+ const char *src);
+error *create_program_with_binary(clobj_t *program, clobj_t context,
+ cl_uint num_devices, const clobj_t *devices,
+ char **binaries, size_t *binary_sizes);
error *program__build(clobj_t program, const char *options,
cl_uint num_devices, const clobj_t *devices);
error *program__kind(clobj_t program, int *kind);
error *program__get_build_info(clobj_t program, clobj_t device,
cl_program_build_info param, generic_info *out);
-
-error *_create_sampler(clobj_t *sampler, clobj_t context,
- int normalized_coordinates, cl_addressing_mode am,
- cl_filter_mode fm);
-
-error *event__get_profiling_info(clobj_t event, cl_profiling_info param,
- generic_info *out);
-error *event__wait(clobj_t event);
-
-error *_create_kernel(clobj_t *kernel, clobj_t program, const char *name);
+// Sampler
+error *create_sampler(clobj_t *sampler, clobj_t context, int norm_coords,
+ cl_addressing_mode am, cl_filter_mode fm);
+// Kernel
+error *create_kernel(clobj_t *kernel, clobj_t program, const char *name);
error *kernel__set_arg_null(clobj_t kernel, cl_uint arg_index);
error *kernel__set_arg_mem(clobj_t kernel, cl_uint arg_index, clobj_t mem);
error *kernel__set_arg_sampler(clobj_t kernel, cl_uint arg_index,
clobj_t sampler);
error *kernel__set_arg_buf(clobj_t kernel, cl_uint arg_index,
const void *buffer, size_t size);
-
error *kernel__get_work_group_info(clobj_t kernel,
cl_kernel_work_group_info param,
clobj_t device, generic_info *out);
-
-error *_get_supported_image_formats(clobj_t context, cl_mem_flags flags,
- cl_mem_object_type image_type,
- generic_info *out);
-
-error *_create_image_2d(clobj_t *image, clobj_t context, cl_mem_flags flags,
- cl_image_format *fmt, size_t width, size_t height,
- size_t pitch, void *buffer, size_t size);
-error *_create_image_3d(clobj_t *image, clobj_t context, cl_mem_flags flags,
- cl_image_format *fmt, size_t width, size_t height,
- size_t depth, size_t pitch_x, size_t pitch_y,
- void *buffer, size_t size);
+// Image
+error *create_image_2d(clobj_t *image, clobj_t context, cl_mem_flags flags,
+ cl_image_format *fmt, size_t width, size_t height,
+ size_t pitch, void *buffer);
+error *create_image_3d(clobj_t *image, clobj_t context, cl_mem_flags flags,
+ cl_image_format *fmt, size_t width, size_t height,
+ size_t depth, size_t pitch_x, size_t pitch_y,
+ void *buffer);
error *image__get_image_info(clobj_t image, cl_image_info param,
generic_info *out);
-
-error *_enqueue_nd_range_kernel(clobj_t *ptr_event, clobj_t queue,
- clobj_t kernel, cl_uint work_dim,
- const size_t *global_work_offset,
- const size_t *global_work_size,
- const size_t *local_work_size,
- const clobj_t *wait_for, uint32_t num_wait_for);
-
-error *_enqueue_marker_with_wait_list(clobj_t *ptr_event, clobj_t queue,
+// Event
+error *event__get_profiling_info(clobj_t event, cl_profiling_info param,
+ generic_info *out);
+error *event__wait(clobj_t event);
+// enqueue_*
+error *enqueue_nd_range_kernel(clobj_t *event, clobj_t queue,
+ clobj_t kernel, cl_uint work_dim,
+ const size_t *global_work_offset,
+ const size_t *global_work_size,
+ const size_t *local_work_size,
+ const clobj_t *wait_for, uint32_t num_wait_for);
+error *enqueue_marker_with_wait_list(clobj_t *event, clobj_t queue,
+ const clobj_t *wait_for,
+ uint32_t num_wait_for);
+error *enqueue_barrier_with_wait_list(clobj_t *event, clobj_t queue,
const clobj_t *wait_for,
uint32_t num_wait_for);
-error *_enqueue_barrier_with_wait_list(clobj_t *event, clobj_t queue,
- const clobj_t *wait_for,
- uint32_t num_wait_for);
-error *_enqueue_marker(clobj_t *event, clobj_t queue);
-error *_enqueue_barrier(clobj_t queue);
-error *_enqueue_read_buffer(clobj_t *event, clobj_t queue, clobj_t mem,
- void *buffer, size_t size, size_t device_offset,
- const clobj_t *wait_for, uint32_t num_wait_for,
- int is_blocking);
-error *_enqueue_copy_buffer(clobj_t *event, clobj_t queue, clobj_t src,
- clobj_t dst, ptrdiff_t byte_count,
- size_t src_offset, size_t dst_offset,
- const clobj_t *wait_for, uint32_t num_wait_for);
-error *_enqueue_write_buffer(clobj_t *event, clobj_t queue, clobj_t mem,
- const void *buffer, size_t size,
- size_t device_offset, const clobj_t *wait_for,
- uint32_t num_wait_for, int is_blocking);
-error *_enqueue_read_image(clobj_t *event, clobj_t queue, clobj_t mem,
- size_t *origin, size_t *region, void *buffer,
- size_t size, size_t row_pitch, size_t slice_pitch,
+error *enqueue_marker(clobj_t *event, clobj_t queue);
+error *enqueue_barrier(clobj_t queue);
+
+error *enqueue_read_buffer(clobj_t *event, clobj_t queue, clobj_t mem,
+ void *buffer, size_t size, size_t device_offset,
const clobj_t *wait_for, uint32_t num_wait_for,
int is_blocking);
+error *enqueue_copy_buffer(clobj_t *event, clobj_t queue, clobj_t src,
+ clobj_t dst, ptrdiff_t byte_count,
+ size_t src_offset, size_t dst_offset,
+ const clobj_t *wait_for, uint32_t num_wait_for);
+error *enqueue_write_buffer(clobj_t *event, clobj_t queue, clobj_t mem,
+ const void *buffer, size_t size,
+ size_t device_offset, const clobj_t *wait_for,
+ uint32_t num_wait_for, int is_blocking);
+
+error *enqueue_read_image(clobj_t *event, clobj_t queue, clobj_t mem,
+ size_t *origin, size_t *region, void *buffer,
+ size_t row_pitch, size_t slice_pitch,
+ const clobj_t *wait_for, uint32_t num_wait_for,
+ int is_blocking);
+// CL Object
+intptr_t clobj__int_ptr(clobj_t obj);
+error *clobj__get_info(clobj_t obj, cl_uint param, generic_info *out);
+void clobj__delete(clobj_t obj);
-error *_command_queue_finish(clobj_t queue);
-error *_command_queue_flush(clobj_t queue);
-
-intptr_t _int_ptr(clobj_t obj);
error *_from_int_ptr(clobj_t *ptr_out, intptr_t int_ptr_value, class_t);
-error *_get_info(clobj_t obj, cl_uint param, generic_info *out);
-void _delete(clobj_t obj);
-error *_release_memobj(clobj_t obj);
-
-void pyopencl_free_pointer(void*);
-void pyopencl_free_pointer_array(void**, uint32_t size);
-
-int pyopencl_have_gl();
-
-unsigned pyopencl_bitlog2(unsigned long v);
-void pyopencl_set_gc(int (*func)());
-void populate_constants(void(*add)(const char*, const char*, long value));
diff --git a/pyopencl/c_wrapper/wrap_cl_gl_core.h b/pyopencl/c_wrapper/wrap_cl_gl_core.h
index 2d34d9e2..bacfdda5 100644
--- a/pyopencl/c_wrapper/wrap_cl_gl_core.h
+++ b/pyopencl/c_wrapper/wrap_cl_gl_core.h
@@ -1,13 +1,12 @@
-// Everything in here should have a 'pyopencl_' prefix to avoid clashing with
-// other libraries imported via CFFI.
+// Interface between C and Python for GL related functions
-error *_create_from_gl_buffer(clobj_t *ptr, clobj_t context,
- cl_mem_flags flags, GLuint bufobj);
-error *_create_from_gl_renderbuffer(clobj_t *ptr, clobj_t context,
- cl_mem_flags flags, GLuint bufobj);
-error *_enqueue_acquire_gl_objects(
- clobj_t *ptr_event, clobj_t queue, const clobj_t *mem_objects,
+error *create_from_gl_buffer(clobj_t *ptr, clobj_t context,
+ cl_mem_flags flags, GLuint bufobj);
+error *create_from_gl_renderbuffer(clobj_t *ptr, clobj_t context,
+ cl_mem_flags flags, GLuint bufobj);
+error *enqueue_acquire_gl_objects(
+ clobj_t *event, clobj_t queue, const clobj_t *mem_objects,
uint32_t num_mem_objects, const clobj_t *wait_for, uint32_t num_wait_for);
-error *_enqueue_release_gl_objects(
- clobj_t *ptr_event, clobj_t queue, const clobj_t *mem_objects,
+error *enqueue_release_gl_objects(
+ clobj_t *event, clobj_t queue, const clobj_t *mem_objects,
uint32_t num_mem_objects, const clobj_t *wait_for, uint32_t num_wait_for);
diff --git a/pyopencl/cffi_cl.py b/pyopencl/cffi_cl.py
index 3a048c70..3d8728b2 100644
--- a/pyopencl/cffi_cl.py
+++ b/pyopencl/cffi_cl.py
@@ -76,7 +76,7 @@ class _CArray(object):
def __del__(self):
if self.ptr != _ffi.NULL:
- _lib.pyopencl_free_pointer(self.ptr[0])
+ _lib.free_pointer(self.ptr[0])
def __getitem__(self, key):
return self.ptr[0].__getitem__(key)
@@ -88,7 +88,7 @@ class _CArray(object):
class _CArrays(_CArray):
def __del__(self):
- _lib.pyopencl_free_pointer_array(
+ _lib.free_pointer_array(
_ffi.cast('void**', self.ptr[0]), self.size[0])
super(_CArrays, self).__del__()
@@ -125,7 +125,7 @@ def _generic_info_to_python(info):
if type_.endswith(']'):
ret = map(ci, value)
- _lib.pyopencl_free_pointer(info.value)
+ _lib.free_pointer(info.value)
return ret
else:
return ci(value)
@@ -135,9 +135,7 @@ def _generic_info_to_python(info):
ret = ret.decode()
elif type_.startswith('char*['):
ret = map(_ffi.string, value)
- if sys.version_info >= (3,):
- ret = [s.decode() for s in ret]
- _lib.pyopencl_free_pointer_array(info.value, len(value))
+ _lib.free_pointer_array(info.value, len(value))
elif type_.endswith(']'):
if type_.startswith('char['):
# This is usually a CL binary, which may contain NUL characters
@@ -150,17 +148,15 @@ def _generic_info_to_python(info):
elif type_.startswith('generic_info['):
ret = list(map(_generic_info_to_python, value))
elif type_.startswith('cl_image_format['):
- ret = [
- ImageFormat(
- imf.image_channel_order,
- imf.image_channel_data_type)
- for imf in value]
+ ret = [ImageFormat(imf.image_channel_order,
+ imf.image_channel_data_type)
+ for imf in value]
else:
ret = list(value)
else:
ret = value[0]
if info.dontfree == 0:
- _lib.pyopencl_free_pointer(info.value)
+ _lib.free_pointer(info.value)
return ret
# }}}
@@ -184,26 +180,26 @@ class _Common(object):
ptr = _ffi.NULL
def __del__(self):
- _lib._delete(self.ptr)
+ _lib.clobj__delete(self.ptr)
def __eq__(self, other):
return other == self.int_ptr
def __hash__(self):
- return _lib._int_ptr(self.ptr)
+ return _lib.clobj__int_ptr(self.ptr)
def get_info(self, param):
info = _ffi.new('generic_info*')
- _handle_error(_lib._get_info(self.ptr, param, info))
+ _handle_error(_lib.clobj__get_info(self.ptr, param, info))
return _generic_info_to_python(info)
@property
def int_ptr(self):
- return _lib._int_ptr(self.ptr)
+ return _lib.clobj__int_ptr(self.ptr)
@classmethod
def from_int_ptr(cls, int_ptr_value):
- ptr = _ffi.new('void **')
+ ptr = _ffi.new('clobj_t*')
_handle_error(_lib._from_int_ptr(
ptr, int_ptr_value, getattr(_lib, 'CLASS_%s' % cls._id.upper())))
return _create_instance(cls, ptr[0])
@@ -214,9 +210,9 @@ class _Common(object):
def get_cl_header_version():
- v = _lib.pyopencl_get_cl_version()
- return (v >> (3*4),
- (v >> (1*4)) & 0xff)
+ v = _lib.get_cl_version()
+ return (v >> (3 * 4),
+ (v >> (1 * 4)) & 0xff)
# {{{ constants
@@ -312,8 +308,8 @@ def _handle_error(error):
# non-pyopencl exceptions are handled here
import exceptions
e = exceptions.RuntimeError(_ffi.string(error.msg))
- _lib.pyopencl_free_pointer(error.msg)
- _lib.pyopencl_free_pointer(error)
+ _lib.free_pointer(error.msg)
+ _lib.free_pointer(error)
raise e
if error.code == status_code.MEM_OBJECT_ALLOCATION_FAILURE:
klass = MemoryError
@@ -326,9 +322,9 @@ def _handle_error(error):
e = klass(routine=_ffi.string(error.routine),
code=error.code, msg=_ffi.string(error.msg))
- _lib.pyopencl_free_pointer(error.routine)
- _lib.pyopencl_free_pointer(error.msg)
- _lib.pyopencl_free_pointer(error)
+ _lib.free_pointer(error.routine)
+ _lib.free_pointer(error.msg)
+ _lib.free_pointer(error)
raise e
# }}}
@@ -440,7 +436,7 @@ class Context(_Common):
"one of 'devices' or 'dev_type' must be None")
ptr_devices = _ffi.new('void*[]', [device.ptr for device in devices])
ptr_ctx = _ffi.new('void **')
- _handle_error(_lib._create_context(
+ _handle_error(_lib.create_context(
ptr_ctx, c_props, len(ptr_devices),
_ffi.cast('void**', ptr_devices)))
@@ -463,15 +459,15 @@ class CommandQueue(_Common):
ptr_command_queue = _ffi.new('void **')
- _handle_error(_lib._create_command_queue(
+ _handle_error(_lib.create_command_queue(
ptr_command_queue, context.ptr,
_ffi.NULL if device is None else device.ptr, properties))
self.ptr = ptr_command_queue[0]
def finish(self):
- _handle_error(_lib._command_queue_finish(self.ptr))
+ _handle_error(_lib.command_queue__finish(self.ptr))
def flush(self):
- _handle_error(_lib._command_queue_flush(self.ptr))
+ _handle_error(_lib.command_queue__flush(self.ptr))
class MemoryObjectHolder(_Common):
pass
@@ -479,7 +475,7 @@ class MemoryObjectHolder(_Common):
class MemoryObject(MemoryObjectHolder):
def release(self):
- _handle_error(_lib._release_memobj(self.ptr))
+ _handle_error(_lib.memory_object__release(self.ptr))
def _c_buffer_from_obj(obj, writable=False):
"""Convert a Python object to a tuple (cdata('void *'), num_bytes, dummy)
@@ -571,7 +567,7 @@ class Buffer(MemoryObject):
size = hostbuf_size
ptr_buffer = _ffi.new('void **')
- _handle_error(_lib._create_buffer(
+ _handle_error(_lib.create_buffer(
ptr_buffer, context.ptr, flags, size, c_hostbuf))
self.ptr = ptr_buffer[0]
@@ -591,7 +587,7 @@ class _Program(_Common):
def _init_source(self, context, src):
ptr_program = _ffi.new('void **')
- _handle_error(_lib._create_program_with_source(
+ _handle_error(_lib.create_program_with_source(
ptr_program, context.ptr, _convert_str(src)))
self.ptr = ptr_program[0]
@@ -604,17 +600,12 @@ class _Program(_Common):
ptr_program = _ffi.new('void **')
ptr_devices = _ffi.new('void*[]', [device.ptr for device in devices])
ptr_binaries = [_ffi.new('char[%i]' % len(binary), binary)
- for binary in binaries]
+ for binary in binaries]
binary_sizes = _ffi.new('size_t[]', map(len, binaries))
- _handle_error(_lib._create_program_with_binary(
- ptr_program,
- context.ptr,
- len(ptr_devices),
- ptr_devices,
- len(ptr_binaries),
- _ffi.new('char*[]', ptr_binaries),
- binary_sizes))
+ _handle_error(_lib.create_program_with_binary(
+ ptr_program, context.ptr, len(ptr_devices), ptr_devices,
+ _ffi.new('char*[]', ptr_binaries), binary_sizes))
self.ptr = ptr_program[0]
@@ -655,8 +646,8 @@ class Kernel(_Common):
def __init__(self, program, name):
ptr_kernel = _ffi.new('void **')
- _handle_error(_lib._create_kernel(ptr_kernel, program.ptr,
- _convert_str(name)))
+ _handle_error(_lib.create_kernel(ptr_kernel, program.ptr,
+ _convert_str(name)))
self.ptr = ptr_kernel[0]
def set_arg(self, arg_index, arg):
@@ -741,16 +732,9 @@ def enqueue_nd_range_kernel(queue, kernel,
ptr_event = _ffi.new('void **')
c_wait_for, num_wait_for = _c_obj_list(wait_for)
- _handle_error(_lib._enqueue_nd_range_kernel(
- ptr_event,
- queue.ptr,
- kernel.ptr,
- work_dim,
- c_global_work_offset,
- c_global_work_size,
- c_local_work_size,
- c_wait_for, num_wait_for
- ))
+ _handle_error(_lib.enqueue_nd_range_kernel(
+ ptr_event, queue.ptr, kernel.ptr, work_dim, c_global_work_offset,
+ c_global_work_size, c_local_work_size, c_wait_for, num_wait_for))
return _create_instance(Event, ptr_event[0])
# }}}
@@ -760,15 +744,13 @@ def enqueue_nd_range_kernel(queue, kernel,
def _enqueue_marker_with_wait_list(queue, wait_for=None):
ptr_event = _ffi.new('void **')
c_wait_for, num_wait_for = _c_obj_list(wait_for)
- _handle_error(_lib._enqueue_marker_with_wait_list(
- ptr_event,
- queue.ptr,
- c_wait_for, num_wait_for))
+ _handle_error(_lib.enqueue_marker_with_wait_list(
+ ptr_event, queue.ptr, c_wait_for, num_wait_for))
return _create_instance(Event, ptr_event[0])
def _enqueue_marker(queue):
ptr_event = _ffi.new('void **')
- _handle_error(_lib._enqueue_marker(ptr_event, queue.ptr))
+ _handle_error(_lib.enqueue_marker(ptr_event, queue.ptr))
return _create_instance(Event, ptr_event[0])
# }}}
@@ -778,14 +760,12 @@ def _enqueue_marker(queue):
def _enqueue_barrier_with_wait_list(queue, wait_for=None):
ptr_event = _ffi.new('void **')
c_wait_for, num_wait_for = _c_obj_list(wait_for)
- _handle_error(_lib._enqueue_barrier_with_wait_list(
- ptr_event,
- queue.ptr,
- c_wait_for, num_wait_for))
+ _handle_error(_lib.enqueue_barrier_with_wait_list(
+ ptr_event, queue.ptr, c_wait_for, num_wait_for))
return _create_instance(Event, ptr_event[0])
def _enqueue_barrier(queue):
- _handle_error(_lib._enqueue_barrier(queue.ptr))
+ _handle_error(_lib.enqueue_barrier(queue.ptr))
# }}}
@@ -796,16 +776,9 @@ def _enqueue_read_buffer(queue, mem, hostbuf, device_offset=0,
c_buf, size, _ = _c_buffer_from_obj(hostbuf, writable=True)
ptr_event = _ffi.new('void **')
c_wait_for, num_wait_for = _c_obj_list(wait_for)
- _handle_error(_lib._enqueue_read_buffer(
- ptr_event,
- queue.ptr,
- mem.ptr,
- c_buf,
- size,
- device_offset,
- c_wait_for, num_wait_for,
- bool(is_blocking)
- ))
+ _handle_error(_lib.enqueue_read_buffer(
+ ptr_event, queue.ptr, mem.ptr, c_buf, size, device_offset,
+ c_wait_for, num_wait_for, bool(is_blocking)))
return _create_instance(Event, ptr_event[0])
@@ -813,16 +786,9 @@ def _enqueue_copy_buffer(queue, src, dst, byte_count=-1, src_offset=0,
dst_offset=0, wait_for=None):
ptr_event = _ffi.new('void **')
c_wait_for, num_wait_for = _c_obj_list(wait_for)
- _handle_error(_lib._enqueue_copy_buffer(
- ptr_event,
- queue.ptr,
- src.ptr,
- dst.ptr,
- byte_count,
- src_offset,
- dst_offset,
- c_wait_for, num_wait_for,
- ))
+ _handle_error(_lib.enqueue_copy_buffer(
+ ptr_event, queue.ptr, src.ptr, dst.ptr, byte_count, src_offset,
+ dst_offset, c_wait_for, num_wait_for))
return _create_instance(Event, ptr_event[0])
@@ -831,16 +797,9 @@ def _enqueue_write_buffer(queue, mem, hostbuf, device_offset=0,
c_buf, size, _ = _c_buffer_from_obj(hostbuf)
ptr_event = _ffi.new('void **')
c_wait_for, num_wait_for = _c_obj_list(wait_for)
- _handle_error(_lib._enqueue_write_buffer(
- ptr_event,
- queue.ptr,
- mem.ptr,
- c_buf,
- size,
- device_offset,
- c_wait_for, num_wait_for,
- bool(is_blocking)
- ))
+ _handle_error(_lib.enqueue_write_buffer(
+ ptr_event, queue.ptr, mem.ptr, c_buf, size, device_offset,
+ c_wait_for, num_wait_for, bool(is_blocking)))
return _create_instance(Event, ptr_event[0])
# }}}
@@ -848,23 +807,15 @@ def _enqueue_write_buffer(queue, mem, hostbuf, device_offset=0,
# {{{ _enqueue_*_image
-def _enqueue_read_image(queue, mem, origin, region,
- hostbuf, row_pitch=0, slice_pitch=0, wait_for=None, is_blocking=True):
+def _enqueue_read_image(queue, mem, origin, region, hostbuf, row_pitch=0,
+ slice_pitch=0, wait_for=None, is_blocking=True):
c_buf, size, _ = _c_buffer_from_obj(hostbuf, writable=True)
ptr_event = _ffi.new('void **')
c_wait_for, num_wait_for = _c_obj_list(wait_for)
- _handle_error(_lib._enqueue_read_image(
- ptr_event,
- queue.ptr,
- mem.ptr,
- origin,
- region,
- c_buf,
- size,
- row_pitch, slice_pitch,
- c_wait_for, num_wait_for,
- bool(is_blocking)
- ))
+ # TODO check buffer size
+ _handle_error(_lib.enqueue_read_image(
+ ptr_event, queue.ptr, mem.ptr, origin, region, c_buf, row_pitch,
+ slice_pitch, c_wait_for, num_wait_for, bool(is_blocking)))
return _create_instance(Event, ptr_event[0])
# TODO: write_image? copy_image?...
@@ -875,7 +826,7 @@ def _enqueue_read_image(queue, mem, origin, region,
# {{{ gl interop
def have_gl():
- return bool(_lib.pyopencl_have_gl())
+ return bool(_lib.have_gl())
class GLBuffer(MemoryObject):
@@ -883,7 +834,7 @@ class GLBuffer(MemoryObject):
def __init__(self, context, flags, bufobj):
ptr = _ffi.new('void **')
- _handle_error(_lib._create_from_gl_buffer(
+ _handle_error(_lib.create_from_gl_buffer(
ptr, context.ptr, flags, bufobj))
self.ptr = ptr[0]
@@ -893,7 +844,7 @@ class GLRenderBuffer(MemoryObject):
def __init__(self, context, flags, bufobj):
ptr = _ffi.new('void **')
- _handle_error(_lib._create_from_gl_renderbuffer(
+ _handle_error(_lib.create_from_gl_renderbuffer(
ptr, context.ptr, flags, bufobj))
self.ptr = ptr[0]
@@ -914,9 +865,11 @@ def _create_gl_enqueue(what):
return _create_instance(Event, ptr_event[0])
return enqueue_gl_objects
-if _lib.pyopencl_have_gl():
- enqueue_acquire_gl_objects = _create_gl_enqueue(_lib._enqueue_acquire_gl_objects)
- enqueue_release_gl_objects = _create_gl_enqueue(_lib._enqueue_release_gl_objects)
+if _lib.have_gl():
+ enqueue_acquire_gl_objects = _create_gl_enqueue(
+ _lib.enqueue_acquire_gl_objects)
+ enqueue_release_gl_objects = _create_gl_enqueue(
+ _lib.enqueue_release_gl_objects)
# }}}
@@ -1005,7 +958,7 @@ class ImageFormat(object):
def get_supported_image_formats(context, flags, image_type):
info = _ffi.new('generic_info *')
- _handle_error(_lib._get_supported_image_formats(
+ _handle_error(_lib.context__get_supported_image_formats(
context.ptr, flags, image_type, info))
return _generic_info_to_python(info)
@@ -1051,21 +1004,17 @@ class Image(MemoryObject):
"invalid length of pitch tuple")
# check buffer size
- if (buffer is not None
- and max(pitch, width*format.itemsize)*height > size):
+ if (buffer is not None and
+ max(pitch, width * format.itemsize) * height > size):
raise LogicError("Image", status_code.INVALID_VALUE,
"buffer too small")
ptr = _ffi.new('void **')
- _handle_error(_lib._create_image_2d(
- ptr,
- context.ptr,
- flags,
+ _handle_error(_lib.create_image_2d(
+ ptr, context.ptr, flags,
_ffi.new('struct _cl_image_format *',
(format.channel_order, format.channel_data_type, )),
- width, height, pitch,
- c_buf,
- size))
+ width, height, pitch, c_buf))
self.ptr = ptr[0]
elif dims == 3:
width, height, depth = shape
@@ -1078,27 +1027,18 @@ class Image(MemoryObject):
"invalid length of pitch tuple")
# check buffer size
- if (buffer is not None
- and (
- max(
- max(
- pitch_x,
- width*format.itemsize)*height,
- pitch_y
- ) * depth > size)):
+ if (buffer is not None and
+ (max(max(pitch_x, width * format.itemsize) *
+ height, pitch_y) * depth > size)):
raise LogicError("Image", status_code.INVALID_VALUE,
"buffer too small")
ptr = _ffi.new('void **')
- _handle_error(_lib._create_image_3d(
- ptr,
- context.ptr,
- flags,
+ _handle_error(_lib.create_image_3d(
+ ptr, context.ptr, flags,
_ffi.new('struct _cl_image_format *',
(format.channel_order, format.channel_data_type, )),
- width, height, depth, pitch_x, pitch_y,
- c_buf,
- size))
+ width, height, depth, pitch_x, pitch_y, c_buf))
self.ptr = ptr[0]
else:
@@ -1130,12 +1070,8 @@ class Sampler(_Common):
def __init__(self, context, normalized_coords, addressing_mode, filter_mode):
ptr = _ffi.new('void **')
- _handle_error(_lib._create_sampler(
- ptr,
- context.ptr,
- normalized_coords,
- addressing_mode,
- filter_mode))
+ _handle_error(_lib.create_sampler(
+ ptr, context.ptr, normalized_coords, addressing_mode, filter_mode))
self.ptr = ptr[0]
# }}}
diff --git a/pyopencl/tools.py b/pyopencl/tools.py
index 71191906..ef67721b 100644
--- a/pyopencl/tools.py
+++ b/pyopencl/tools.py
@@ -64,7 +64,7 @@ _register_types()
# {{{ imported names
-bitlog2 = _lib.pyopencl_bitlog2
+bitlog2 = _lib.bitlog2
from pyopencl.mempool import ( # noqa
PooledBuffer, DeferredAllocator, ImmediateAllocator, MemoryPool)
diff --git a/src/c_wrapper/bitlog.cpp b/src/c_wrapper/bitlog.cpp
index f7951729..da0cb1de 100644
--- a/src/c_wrapper/bitlog.cpp
+++ b/src/c_wrapper/bitlog.cpp
@@ -1,28 +1,57 @@
-#include "bitlog.h"
#include "wrap_cl.h"
+#include <climits>
+#include <stdint.h>
/* from http://graphics.stanford.edu/~seander/bithacks.html */
-const char pyopencl::log_table_8[] =
-{
- 0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
- 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
- 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
- 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
- 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
- 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
- 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
- 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
+static const char log_table_8[] = {
+ 0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
};
-unsigned pyopencl_bitlog2(unsigned long v)
+static inline unsigned
+bitlog2_16(uint16_t v)
+{
+ if (unsigned long t = v >> 8) {
+ return 8 + log_table_8[t];
+ } else {
+ return log_table_8[v];
+ }
+}
+
+static inline unsigned
+bitlog2_32(uint32_t v)
+{
+ if (uint16_t t = v >> 16) {
+ return 16 + bitlog2_16(t);
+ } else {
+ return bitlog2_16(v);
+ }
+}
+
+unsigned
+bitlog2(unsigned long v)
{
- return pyopencl::bitlog2(v);
+#if (ULONG_MAX != 4294967295)
+ if (uint32_t t = v >> 32) {
+ return 32 + bitlog2_32(t);
+ } else {
+#endif
+ return bitlog2_32(v);
+#if (ULONG_MAX != 4294967295)
+ }
+#endif
}
diff --git a/src/c_wrapper/bitlog.h b/src/c_wrapper/bitlog.h
deleted file mode 100644
index fde67e8d..00000000
--- a/src/c_wrapper/bitlog.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// Base-2 logarithm bithack.
-
-#ifndef _AFJDFJSDFSD_PYOPENCL_HEADER_SEEN_BITLOG_HPP
-#define _AFJDFJSDFSD_PYOPENCL_HEADER_SEEN_BITLOG_HPP
-
-#include <climits>
-#include <stdint.h>
-
-namespace pyopencl
-{
- extern const char log_table_8[];
-
- static inline unsigned bitlog2_16(uint16_t v)
- {
- if (unsigned long t = v >> 8)
- return 8 + log_table_8[t];
- else
- return log_table_8[v];
- }
-
- static inline unsigned bitlog2_32(uint32_t v)
- {
- if (uint16_t t = v >> 16)
- return 16 + bitlog2_16(t);
- else
- return bitlog2_16(v);
- }
-
- static inline unsigned bitlog2(unsigned long v)
- {
-#if (ULONG_MAX != 4294967295)
- if (uint32_t t = v >> 32)
- return 32 + bitlog2_32(t);
- else
-#endif
- return bitlog2_32(v);
- }
-}
-
-#endif
diff --git a/src/c_wrapper/error.h b/src/c_wrapper/error.h
index 66039fe1..491b65f2 100644
--- a/src/c_wrapper/error.h
+++ b/src/c_wrapper/error.h
@@ -56,13 +56,13 @@ print_call_trace(ArgTypes&&...)
// {{{ error
-class error : public std::runtime_error {
+class clerror : public std::runtime_error {
private:
const char *m_routine;
cl_int m_code;
public:
- error(const char *rout, cl_int c, const char *msg="")
+ clerror(const char *rout, cl_int c, const char *msg="")
: std::runtime_error(msg), m_routine(rout), m_code(c)
{
std::cout << rout <<";" << msg<< ";" << c << std::endl;
@@ -99,7 +99,7 @@ call_guarded(cl_int (*func)(ArgTypes...), const char *name, ArgTypes2&&... args)
print_call_trace(name);
cl_int status_code = func(ArgTypes(args)...);
if (status_code != CL_SUCCESS) {
- throw pyopencl::error(name, status_code);
+ throw clerror(name, status_code);
}
}
@@ -111,7 +111,7 @@ call_guarded(T (*func)(ArgTypes...), const char *name, ArgTypes2&&... args)
cl_int status_code = CL_SUCCESS;
T res = func(args..., &status_code);
if (status_code != CL_SUCCESS) {
- throw pyopencl::error(name, status_code);
+ throw clerror(name, status_code);
}
return res;
}
@@ -141,7 +141,7 @@ c_handle_error(std::function<void()> func)
try {
func();
return NULL;
- } catch(const pyopencl::error &e) {
+ } catch(const clerror &e) {
auto err = (::error*)malloc(sizeof(::error));
err->routine = strdup(e.routine());
err->msg = strdup(e.what());
@@ -163,7 +163,7 @@ retry_mem_error(std::function<T()> func)
{
try {
return func();
- } catch (pyopencl::error &e) {
+ } catch (clerror &e) {
if (!e.is_out_of_memory() || !python_gc()) {
throw;
}
diff --git a/src/c_wrapper/wrap_cl.cpp b/src/c_wrapper/wrap_cl.cpp
index 9dbc39b4..f4e6faa8 100644
--- a/src/c_wrapper/wrap_cl.cpp
+++ b/src/c_wrapper/wrap_cl.cpp
@@ -6,23 +6,30 @@
// {{{ extension function pointers
#if PYOPENCL_CL_VERSION >= 0x1020
-
-#define PYOPENCL_GET_EXT_FUN(PLATFORM, NAME, VAR) \
- NAME##_fn VAR = (NAME##_fn) \
- clGetExtensionFunctionAddressForPlatform(PLATFORM, #NAME); \
- \
- if (!VAR) \
- throw error(#NAME, CL_INVALID_VALUE, #NAME " not available");
-
+template<typename T>
+static inline T
+pyopencl_get_ext_fun(cl_platform_id plat, const char *name, const char *err)
+{
+ T func = (T)clGetExtensionFunctionAddressForPlatform(plat, name);
+ if (!func) {
+ throw pyopencl::clerror(name, CL_INVALID_VALUE, err);
+ }
+ return func;
+}
#else
-
-#define PYOPENCL_GET_EXT_FUN(PLATFORM, NAME, VAR) \
- NAME##_fn VAR = (NAME##_fn) clGetExtensionFunctionAddress(#NAME); \
- \
- if (!VAR) \
- throw error(#NAME, CL_INVALID_VALUE, #NAME " not available");
-
+template<typename T>
+static inline T
+pyopencl_get_ext_fun(cl_platform_id, const char *name, const char *err)
+{
+ T func = (T)clGetExtensionFunctionAddress(name);
+ if (!func) {
+ throw pyopencl::clerror(name, CL_INVALID_VALUE, err);
+ }
+ return func;
+}
#endif
+#define pyopencl_get_ext_fun(plat, name) \
+ pyopencl_get_ext_fun<name##_fn>(plat, #name, #name " not available")
// }}}
@@ -51,7 +58,7 @@
case ::CLASS_IMAGE: OPERATION(IMAGE, image); break; \
case ::CLASS_SAMPLER: OPERATION(SAMPLER, sampler); break; \
GL_SWITCHCLASS(OPERATION) \
- default: throw pyopencl::error("unknown class", CL_INVALID_VALUE); \
+ default: throw pyopencl::clerror("unknown class", CL_INVALID_VALUE); \
}
#define PYOPENCL_CL_PLATFORM cl_platform_id
@@ -99,7 +106,7 @@ public:
return pyopencl_get_str_info(Platform, data(), param_name);
default:
- throw error("Platform.get_info", CL_INVALID_VALUE);
+ throw clerror("Platform.get_info", CL_INVALID_VALUE);
}
}
@@ -114,7 +121,7 @@ platform::get_devices(cl_device_type devtype)
try {
pyopencl_call_guarded(clGetDeviceIDs,
data(), devtype, 0, NULL, &num_devices);
- } catch (const pyopencl::error &e) {
+ } catch (const clerror &e) {
if (e.code() != CL_DEVICE_NOT_FOUND)
throw e;
num_devices = 0;
@@ -166,8 +173,8 @@ public:
CL_DEVICE_PLATFORM, sizeof(plat),
&plat, NULL);
#endif
- PYOPENCL_GET_EXT_FUN(plat, clRetainDeviceEXT, retain_func);
- pyopencl_call_guarded(retain_func, did);
+ pyopencl_call_guarded(
+ pyopencl_get_ext_fun(plat, clRetainDeviceEXT), did);
}
#endif
#if PYOPENCL_CL_VERSION >= 0x1020
@@ -177,9 +184,9 @@ public:
#endif
else {
- throw error("Device", CL_INVALID_VALUE,
- "cannot own references to devices when device "
- "fission or CL 1.2 is not available");
+ throw clerror("Device", CL_INVALID_VALUE,
+ "cannot own references to devices when device "
+ "fission or CL 1.2 is not available");
}
}
}
@@ -195,8 +202,8 @@ public:
pyopencl_call_guarded(clGetDeviceInfo, data(), CL_DEVICE_PLATFORM,
sizeof(plat), &plat, NULL);
#endif
- PYOPENCL_GET_EXT_FUN(plat, clReleaseDeviceEXT, release_func);
- pyopencl_call_guarded_cleanup(release_func, data());
+ pyopencl_call_guarded_cleanup(
+ pyopencl_get_ext_fun(plat, clReleaseDeviceEXT), data());
}
#endif
#if PYOPENCL_CL_VERSION >= 0x1020
@@ -418,7 +425,7 @@ public:
// }}}
default:
- throw error("Device.get_info", CL_INVALID_VALUE);
+ throw clerror("Device.get_info", CL_INVALID_VALUE);
}
}
@@ -559,8 +566,8 @@ public:
#endif
default:
- throw error("Context.get_info", CL_INVALID_VALUE,
- "unknown context_property key encountered");
+ throw clerror("Context.get_info", CL_INVALID_VALUE,
+ "unknown context_property key encountered");
}
}
py_result.resize(i);
@@ -574,9 +581,21 @@ public:
#endif
default:
- throw error("Context.get_info", CL_INVALID_VALUE);
+ throw clerror("Context.get_info", CL_INVALID_VALUE);
}
}
+ inline generic_info
+ get_supported_image_formats(cl_mem_flags flags,
+ cl_mem_object_type image_type) const
+ {
+ cl_uint num_image_formats;
+ pyopencl_call_guarded(clGetSupportedImageFormats, data(), flags,
+ image_type, 0, NULL, &num_image_formats);
+ pyopencl_buf<cl_image_format> formats(num_image_formats);
+ pyopencl_call_guarded(clGetSupportedImageFormats, data(), flags,
+ image_type, formats.len(), formats.get(), NULL);
+ return pyopencl_convert_array_info(cl_image_format, formats);
+ }
};
// }}}
@@ -587,8 +606,8 @@ public:
class command_queue : public clobj<cl_command_queue> {
private:
static cl_command_queue
- create_command_queue(const context *ctx, const device *py_dev,
- cl_command_queue_properties props)
+ create_cl_command_queue(const context *ctx, const device *py_dev,
+ cl_command_queue_properties props)
{
cl_device_id dev;
if (py_dev) {
@@ -597,9 +616,9 @@ private:
auto devs = pyopencl_get_vec_info(cl_device_id, Context,
ctx->data(), CL_CONTEXT_DEVICES);
if (devs.len() == 0) {
- throw pyopencl::error("CommandQueue", CL_INVALID_VALUE,
- "context doesn't have any devices? -- "
- "don't know which one to default to");
+ throw clerror("CommandQueue", CL_INVALID_VALUE,
+ "context doesn't have any devices? -- "
+ "don't know which one to default to");
}
dev = devs[0];
}
@@ -617,7 +636,7 @@ public:
}
command_queue(const context *ctx, const device *py_dev=0,
cl_command_queue_properties props=0)
- : clobj(create_command_queue(ctx, py_dev, props))
+ : clobj(create_cl_command_queue(ctx, py_dev, props))
{}
~command_queue()
{
@@ -641,7 +660,7 @@ public:
return pyopencl_get_int_info(cl_command_queue_properties,
CommandQueue, data(), param_name);
default:
- throw error("CommandQueue.get_info", CL_INVALID_VALUE);
+ throw clerror("CommandQueue.get_info", CL_INVALID_VALUE);
}
}
@@ -715,7 +734,7 @@ public:
#endif
default:
- throw error("Event.get_info", CL_INVALID_VALUE);
+ throw clerror("Event.get_info", CL_INVALID_VALUE);
}
}
generic_info
@@ -729,7 +748,7 @@ public:
return pyopencl_get_int_info(cl_ulong, EventProfiling,
data(), param_name);
default:
- throw error("Event.get_profiling_info", CL_INVALID_VALUE);
+ throw clerror("Event.get_profiling_info", CL_INVALID_VALUE);
}
}
@@ -739,7 +758,6 @@ public:
pyopencl_call_guarded(clWaitForEvents, 1, &data());
}
};
-
static inline event*
new_event(cl_event evt)
{
@@ -775,9 +793,9 @@ public:
case CL_MEM_SIZE:
return pyopencl_get_int_info(size_t, MemObject, data(), param_name);
case CL_MEM_HOST_PTR:
- throw pyopencl::error("MemoryObject.get_info", CL_INVALID_VALUE,
- "Use MemoryObject.get_host_array to get "
- "host pointer.");
+ throw clerror("MemoryObject.get_info", CL_INVALID_VALUE,
+ "Use MemoryObject.get_host_array to get "
+ "host pointer.");
case CL_MEM_MAP_COUNT:
case CL_MEM_REFERENCE_COUNT:
return pyopencl_get_int_info(cl_uint, MemObject,
@@ -805,7 +823,7 @@ public:
#endif
default:
- throw error("MemoryObjectHolder.get_info", CL_INVALID_VALUE);
+ throw clerror("MemoryObjectHolder.get_info", CL_INVALID_VALUE);
}
}
};
@@ -816,7 +834,7 @@ private:
void *m_hostbuf;
public:
memory_object(cl_mem mem, bool retain, void *hostbuf=0)
- : m_valid(true), memory_object_holder(mem)
+ : memory_object_holder(mem), m_valid(true)
{
if (retain) {
pyopencl_call_guarded(clRetainMemObject, mem);
@@ -829,8 +847,8 @@ public:
release()
{
if (!m_valid)
- throw error("MemoryObject.free", CL_INVALID_VALUE,
- "trying to double-unref mem object");
+ throw clerror("MemoryObject.free", CL_INVALID_VALUE,
+ "trying to double-unref mem object");
pyopencl_call_guarded_cleanup(clReleaseMemObject, data());
m_valid = false;
}
@@ -847,89 +865,87 @@ public:
}
};
- // #if PYOPENCL_CL_VERSION >= 0x1020
- // inline
- // event *enqueue_migrate_mem_objects(
- // command_queue &cq,
- // py::object py_mem_objects,
- // cl_mem_migration_flags flags,
- // py::object py_wait_for)
- // {
- // PYOPENCL_PARSE_WAIT_FOR;
-
- // std::vector<cl_mem> mem_objects;
- // PYTHON_FOREACH(mo, py_mem_objects)
- // mem_objects.push_back(py::extract<memory_object &>(mo)().data());
-
- // cl_event evt;
- // PYOPENCL_RETRY_IF_MEM_ERROR(
- // PYOPENCL_CALL_GUARDED(clEnqueueMigrateMemObjects, (
- // cq.data(),
- // mem_objects.size(), mem_objects.empty( ) ? NULL : &mem_objects.front(),
- // flags,
- // PYOPENCL_WAITLIST_ARGS, &evt
- // ));
- // );
- // PYOPENCL_RETURN_NEW_EVENT(evt);
- // }
- // #endif
-
- // #ifdef cl_ext_migrate_memobject
- // inline
- // event *enqueue_migrate_mem_object_ext(
- // command_queue &cq,
- // py::object py_mem_objects,
- // cl_mem_migration_flags_ext flags,
- // py::object py_wait_for)
- // {
- // PYOPENCL_PARSE_WAIT_FOR;
-
- // #if PYOPENCL_CL_VERSION >= 0x1020
- // // {{{ get platform
- // cl_device_id dev;
- // PYOPENCL_CALL_GUARDED(clGetCommandQueueInfo, (cq.data(), CL_QUEUE_DEVICE,
- // sizeof(dev), &dev, NULL));
- // cl_platform_id plat;
- // PYOPENCL_CALL_GUARDED(clGetDeviceInfo, (cq.data(), CL_DEVICE_PLATFORM,
- // sizeof(plat), &plat, NULL));
- // // }}}
- // #endif
-
- // PYOPENCL_GET_EXT_FUN(plat,
- // clEnqueueMigrateMemObjectEXT, enqueue_migrate_fn);
-
- // std::vector<cl_mem> mem_objects;
- // PYTHON_FOREACH(mo, py_mem_objects)
- // mem_objects.push_back(py::extract<memory_object &>(mo)().data());
-
- // cl_event evt;
- // PYOPENCL_RETRY_IF_MEM_ERROR(
- // PYOPENCL_CALL_GUARDED(enqueue_migrate_fn, (
- // cq.data(),
- // mem_objects.size(), mem_objects.empty( ) ? NULL : &mem_objects.front(),
- // flags,
- // PYOPENCL_WAITLIST_ARGS, &evt
- // ));
- // );
- // PYOPENCL_RETURN_NEW_EVENT(evt);
- // }
- // #endif
-
- // }}}
+// #if PYOPENCL_CL_VERSION >= 0x1020
+// inline
+// event *enqueue_migrate_mem_objects(
+// command_queue &cq,
+// py::object py_mem_objects,
+// cl_mem_migration_flags flags,
+// py::object py_wait_for)
+// {
+// PYOPENCL_PARSE_WAIT_FOR;
+
+// std::vector<cl_mem> mem_objects;
+// PYTHON_FOREACH(mo, py_mem_objects)
+// mem_objects.push_back(py::extract<memory_object &>(mo)().data());
+
+// cl_event evt;
+// PYOPENCL_RETRY_IF_MEM_ERROR(
+// PYOPENCL_CALL_GUARDED(clEnqueueMigrateMemObjects, (
+// cq.data(),
+// mem_objects.size(), mem_objects.empty( ) ? NULL : &mem_objects.front(),
+// flags,
+// PYOPENCL_WAITLIST_ARGS, &evt
+// ));
+// );
+// PYOPENCL_RETURN_NEW_EVENT(evt);
+// }
+// #endif
+
+// #ifdef cl_ext_migrate_memobject
+// inline
+// event *enqueue_migrate_mem_object_ext(
+// command_queue &cq,
+// py::object py_mem_objects,
+// cl_mem_migration_flags_ext flags,
+// py::object py_wait_for)
+// {
+// PYOPENCL_PARSE_WAIT_FOR;
+
+// #if PYOPENCL_CL_VERSION >= 0x1020
+// // {{{ get platform
+// cl_device_id dev;
+// PYOPENCL_CALL_GUARDED(clGetCommandQueueInfo, (cq.data(), CL_QUEUE_DEVICE,
+// sizeof(dev), &dev, NULL));
+// cl_platform_id plat;
+// PYOPENCL_CALL_GUARDED(clGetDeviceInfo, (cq.data(), CL_DEVICE_PLATFORM,
+// sizeof(plat), &plat, NULL));
+// // }}}
+// #endif
+
+// PYOPENCL_GET_EXT_FUN(plat,
+// clEnqueueMigrateMemObjectEXT, enqueue_migrate_fn);
+
+// std::vector<cl_mem> mem_objects;
+// PYTHON_FOREACH(mo, py_mem_objects)
+// mem_objects.push_back(py::extract<memory_object &>(mo)().data());
+
+// cl_event evt;
+// PYOPENCL_RETRY_IF_MEM_ERROR(
+// PYOPENCL_CALL_GUARDED(enqueue_migrate_fn, (
+// cq.data(),
+// mem_objects.size(), mem_objects.empty( ) ? NULL : &mem_objects.front(),
+// flags,
+// PYOPENCL_WAITLIST_ARGS, &evt
+// ));
+// );
+// PYOPENCL_RETURN_NEW_EVENT(evt);
+// }
+// #endif
+// }}}
- // {{{ image
+// {{{ image
- class image : public memory_object
- {
- public:
- PYOPENCL_DEF_GET_CLASS_T(IMAGE);
- image(cl_mem mem, bool retain, void *hostbuf=0)
+class image : public memory_object {
+public:
+ PYOPENCL_DEF_GET_CLASS_T(IMAGE);
+ image(cl_mem mem, bool retain, void *hostbuf=0)
: memory_object(mem, retain, hostbuf)
- { }
-
- generic_info get_image_info(cl_image_info param_name) const
- {
+ {}
+ generic_info
+ get_image_info(cl_image_info param_name) const
+ {
switch (param_name) {
case CL_IMAGE_FORMAT:
return pyopencl_get_int_info(cl_image_format, Image,
@@ -966,143 +982,77 @@ public:
#endif
default:
- throw error("Image.get_image_info", CL_INVALID_VALUE);
+ throw clerror("Image.get_image_info", CL_INVALID_VALUE);
}
- }
- };
+ }
+};
static inline image*
new_image(cl_mem mem, void *buff=0)
{
return pyopencl_convert_obj(image, clReleaseMemObject, mem, buff);
}
-// {{{ image formats
-
-inline generic_info
-get_supported_image_formats(const context *ctx, cl_mem_flags flags,
- cl_mem_object_type image_type)
-{
- cl_uint num_image_formats;
- pyopencl_call_guarded(clGetSupportedImageFormats,
- ctx->data(), flags, image_type,
- 0, NULL, &num_image_formats);
-
- pyopencl_buf<cl_image_format> formats(num_image_formats);
- pyopencl_call_guarded(clGetSupportedImageFormats,
- ctx->data(), flags, image_type,
- formats.len(), formats.get(), NULL);
-
- return pyopencl_convert_array_info(cl_image_format, formats);
-}
-
-// }}}
-
// {{{ image creation
-inline image*
-create_image_2d(const context *ctx, cl_mem_flags flags,
- const cl_image_format *fmt, size_t width, size_t height,
- size_t pitch, void *buffer, size_t size)
-{
- auto mem = retry_mem_error<cl_mem>([&] {
- return pyopencl_call_guarded(clCreateImage2D, ctx->data(), flags,
- fmt, width, height, pitch, buffer);
- });
- return new_image(mem, flags & CL_MEM_USE_HOST_PTR ? buffer : NULL);
-}
-
-inline image*
-create_image_3d(const context *ctx, cl_mem_flags flags,
- const cl_image_format *fmt, size_t width, size_t height,
- size_t depth, size_t pitch_x, size_t pitch_y,
- void *buffer, size_t size)
-{
- auto mem = retry_mem_error<cl_mem>([&] {
- return pyopencl_call_guarded(clCreateImage3D, ctx->data(), flags,
- fmt, width, height, depth, pitch_x,
- pitch_y, buffer);
- });
- return new_image(mem, flags & CL_MEM_USE_HOST_PTR ? buffer : NULL);
-}
-
-
- // #if PYOPENCL_CL_VERSION >= 0x1020
-
- // inline
- // image *create_image_from_desc(
- // context const &ctx,
- // cl_mem_flags flags,
- // cl_image_format const &fmt,
- // cl_image_desc &desc,
- // py::object buffer)
- // {
- // if (buffer.ptr() != Py_None &&
- // !(flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR)))
- // PyErr_Warn(PyExc_UserWarning, "'hostbuf' was passed, "
- // "but no memory flags to make use of it.");
-
- // void *buf = 0;
- // PYOPENCL_BUFFER_SIZE_T len;
- // py::object *retained_buf_obj = 0;
-
- // if (buffer.ptr() != Py_None)
- // {
- // if (flags & CL_MEM_USE_HOST_PTR)
- // {
- // if (PyObject_AsWriteBuffer(buffer.ptr(), &buf, &len))
- // throw py::error_already_set();
- // }
- // else
- // {
- // if (PyObject_AsReadBuffer(
- // buffer.ptr(), const_cast<const void **>(&buf), &len))
- // throw py::error_already_set();
- // }
-
- // if (flags & CL_MEM_USE_HOST_PTR)
- // retained_buf_obj = &buffer;
- // }
-
- // PYOPENCL_PRINT_CALL_TRACE("clCreateImage");
- // cl_int status_code;
- // cl_mem mem = clCreateImage(ctx.data(), flags, &fmt, &desc, buf, &status_code);
- // if (status_code != CL_SUCCESS)
- // throw pyopencl::error("clCreateImage", status_code);
-
- // try
- // {
- // return new image(mem, false, retained_buf_obj);
- // }
- // catch (...)
- // {
- // PYOPENCL_CALL_GUARDED(clReleaseMemObject, (mem));
- // throw;
- // }
- // }
+// #if PYOPENCL_CL_VERSION >= 0x1020
+
+// inline
+// image *create_image_from_desc(
+// context const &ctx,
+// cl_mem_flags flags,
+// cl_image_format const &fmt,
+// cl_image_desc &desc,
+// py::object buffer)
+// {
+// if (buffer.ptr() != Py_None &&
+// !(flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR)))
+// PyErr_Warn(PyExc_UserWarning, "'hostbuf' was passed, "
+// "but no memory flags to make use of it.");
+
+// void *buf = 0;
+// PYOPENCL_BUFFER_SIZE_T len;
+// py::object *retained_buf_obj = 0;
+
+// if (buffer.ptr() != Py_None)
+// {
+// if (flags & CL_MEM_USE_HOST_PTR)
+// {
+// if (PyObject_AsWriteBuffer(buffer.ptr(), &buf, &len))
+// throw py::error_already_set();
+// }
+// else
+// {
+// if (PyObject_AsReadBuffer(
+// buffer.ptr(), const_cast<const void **>(&buf), &len))
+// throw py::error_already_set();
+// }
+
+// if (flags & CL_MEM_USE_HOST_PTR)
+// retained_buf_obj = &buffer;
+// }
+
+// PYOPENCL_PRINT_CALL_TRACE("clCreateImage");
+// cl_int status_code;
+// cl_mem mem = clCreateImage(ctx.data(), flags, &fmt, &desc, buf, &status_code);
+// if (status_code != CL_SUCCESS)
+// throw clerror("clCreateImage", status_code);
+
+// try
+// {
+// return new image(mem, false, retained_buf_obj);
+// }
+// catch (...)
+// {
+// PYOPENCL_CALL_GUARDED(clReleaseMemObject, (mem));
+// throw;
+// }
+// }
+
+// #endif
- // #endif
-
- // }}}
-
- // {{{ image transfers
+// }}}
-inline event*
-enqueue_read_image(command_queue *cq, image *img, size_t *origin,
- size_t *region, void *buffer, size_t size, size_t row_pitch,
- size_t slice_pitch, const clobj_t *wait_for,
- uint32_t num_wait_for, bool is_blocking)
-{
- auto _wait_for = buf_from_class<event>(wait_for, num_wait_for);
- cl_event evt;
- retry_mem_error<void>([&] {
- pyopencl_call_guarded(clEnqueueReadImage, cq->data(), img->data(),
- cast_bool(is_blocking), origin, region,
- row_pitch, slice_pitch, buffer,
- num_wait_for, _wait_for.get(), &evt);
- });
- return new_event(evt);
- //PYOPENCL_RETURN_NEW_NANNY_EVENT(evt, buffer);
-}
+// {{{ image transfers
// inline
// event *enqueue_write_image(
@@ -1137,9 +1087,6 @@ enqueue_read_image(command_queue *cq, image *img, size_t *origin,
// PYOPENCL_RETURN_NEW_NANNY_EVENT(evt, buffer);
// }
-
-
-
// inline
// event *enqueue_copy_image(
// command_queue &cq,
@@ -1167,9 +1114,6 @@ enqueue_read_image(command_queue *cq, image *img, size_t *origin,
// PYOPENCL_RETURN_NEW_EVENT(evt);
// }
-
-
-
// inline
// event *enqueue_copy_image_to_buffer(
// command_queue &cq,
@@ -1263,25 +1207,21 @@ enqueue_read_image(command_queue *cq, image *img, size_t *origin,
// }}}
-
-
- // {{{ gl interop
-
+// {{{ gl interop
#ifdef HAVE_GL
#ifdef __APPLE__
- inline
- cl_context_properties get_apple_cgl_share_group()
- {
+static inline cl_context_properties
+get_apple_cgl_share_group()
+{
CGLContextObj kCGLContext = CGLGetCurrentContext();
CGLShareGroupObj kCGLShareGroup = CGLGetShareGroup(kCGLContext);
- return (cl_context_properties) kCGLShareGroup;
- }
+ return (cl_context_properties)kCGLShareGroup;
+}
#endif /* __APPLE__ */
-
class gl_buffer : public memory_object {
public:
PYOPENCL_DEF_GET_CLASS_T(GL_BUFFER);
@@ -1295,29 +1235,29 @@ public:
PYOPENCL_DEF_GET_CLASS_T(GL_RENDERBUFFER);
gl_renderbuffer(cl_mem mem, bool retain, void *hostbuf=0)
: memory_object(mem, retain, hostbuf)
- { }
+ {}
};
class gl_texture : public image {
public:
gl_texture(cl_mem mem, bool retain, void *hostbuf=0)
: image(mem, retain, hostbuf)
- { }
-
- generic_info get_gl_texture_info(cl_gl_texture_info param_name)
+ {}
+ generic_info
+ get_gl_texture_info(cl_gl_texture_info param_name)
{
- switch (param_name) {
- case CL_GL_TEXTURE_TARGET:
- return pyopencl_get_int_info(GLenum, GLTexture, data(), param_name);
- case CL_GL_MIPMAP_LEVEL:
- return pyopencl_get_int_info(GLint, GLTexture, data(), param_name);
- default:
- throw error("MemoryObject.get_gl_texture_info", CL_INVALID_VALUE);
- }
+ switch (param_name) {
+ case CL_GL_TEXTURE_TARGET:
+ return pyopencl_get_int_info(GLenum, GLTexture, data(), param_name);
+ case CL_GL_MIPMAP_LEVEL:
+ return pyopencl_get_int_info(GLint, GLTexture, data(), param_name);
+ default:
+ throw clerror("MemoryObject.get_gl_texture_info", CL_INVALID_VALUE);
+ }
}
- };
+};
-inline gl_texture*
+static gl_texture*
create_from_gl_texture(context &ctx, cl_mem_flags flags, GLenum texture_target,
GLint miplevel, GLuint texture, unsigned dims)
{
@@ -1332,7 +1272,7 @@ create_from_gl_texture(context &ctx, cl_mem_flags flags, GLenum texture_target,
miplevel, texture);
return pyopencl_convert_obj(gl_texture, clReleaseMemObject, mem);
} else {
- throw pyopencl::error("Image", CL_INVALID_VALUE, "invalid dimension");
+ throw clerror("Image", CL_INVALID_VALUE, "invalid dimension");
}
}
@@ -1506,7 +1446,7 @@ public:
// throw py::error_already_set();
// if (stride != 1)
- // throw pyopencl::error("Buffer.__getitem__", CL_INVALID_VALUE,
+ // throw clerror("Buffer.__getitem__", CL_INVALID_VALUE,
// "Buffer slice must have stride 1");
// cl_mem_flags my_flags;
@@ -1523,27 +1463,10 @@ new_buffer(cl_mem mem, void *buff)
return pyopencl_convert_obj(buffer, clReleaseMemObject, mem, buff);
}
-// {{{ buffer creation
-
-inline buffer*
-create_buffer(context *ctx, cl_mem_flags flags, size_t size, void *py_hostbuf)
-{
- void *retained_buf_obj = 0;
- if (py_hostbuf != NULL && flags & CL_MEM_USE_HOST_PTR) {
- retained_buf_obj = py_hostbuf;
- }
- auto mem = retry_mem_error<cl_mem>([&] {
- return pyopencl_call_guarded(clCreateBuffer, ctx->data(),
- flags, size, py_hostbuf);
- });
- return new_buffer(mem, retained_buf_obj);
-}
-
-// }}}
// }}}
-
// {{{ sampler
+
class sampler : public clobj<cl_sampler> {
public:
PYOPENCL_DEF_GET_CLASS_T(SAMPLER);
@@ -1584,7 +1507,7 @@ public:
data(), param_name);
default:
- throw error("Sampler.get_info", CL_INVALID_VALUE);
+ throw clerror("Sampler.get_info", CL_INVALID_VALUE);
}
}
};
@@ -1674,7 +1597,7 @@ public:
return pyopencl_get_str_info(Program, data(), param_name);
#endif
default:
- throw error("Program.get_info", CL_INVALID_VALUE);
+ throw clerror("Program.get_info", CL_INVALID_VALUE);
}
}
generic_info
@@ -1694,7 +1617,7 @@ public:
data(), dev->data(), param_name);
#endif
default:
- throw error("Program.get_build_info", CL_INVALID_VALUE);
+ throw clerror("Program.get_build_info", CL_INVALID_VALUE);
}
}
void
@@ -1749,32 +1672,6 @@ new_program(cl_program prog, program_kind_type progkind=KND_UNKNOWN)
return pyopencl_convert_obj(program, clReleaseProgram, prog, progkind);
}
-inline program*
-create_program_with_source(context *ctx, const char *string)
-{
- size_t length = strlen(string);
- cl_program result = pyopencl_call_guarded(clCreateProgramWithSource,
- ctx->data(), 1, &string, &length);
- return new_program(result, KND_SOURCE);
-}
-
-
-inline program*
-create_program_with_binary(context *ctx, cl_uint num_devices,
- const clobj_t *ptr_devices, cl_uint num_binaries,
- char **binaries, size_t *binary_sizes)
-{
- auto devices = buf_from_class<device>(ptr_devices, num_devices);
- pyopencl_buf<cl_int> binary_statuses(num_devices);
- cl_program result = pyopencl_call_guarded(
- clCreateProgramWithBinary, ctx->data(), num_devices, devices.get(),
- binary_sizes, reinterpret_cast<const unsigned char**>(
- const_cast<const char**>(binaries)), binary_statuses.get());
- // for (cl_uint i = 0; i < num_devices; ++i)
- // std::cout << i << ":" << binary_statuses[i] << std::endl;
- return new_program(result, KND_BINARY);
-}
-
// }}}
// {{{ kernel
@@ -1844,7 +1741,7 @@ public:
return pyopencl_get_str_info(Kernel, data(), param_name);
#endif
default:
- throw error("Kernel.get_info", CL_INVALID_VALUE);
+ throw clerror("Kernel.get_info", CL_INVALID_VALUE);
}
}
generic_info
@@ -1868,7 +1765,7 @@ public:
return pyopencl_get_int_info(cl_ulong, KernelWorkGroup,
data(), dev->data(), param_name);
default:
- throw error("Kernel.get_work_group_info", CL_INVALID_VALUE);
+ throw clerror("Kernel.get_work_group_info", CL_INVALID_VALUE);
}
}
@@ -1904,188 +1801,86 @@ public:
// }}}
-
-// {{{ buffer transfers
-
-inline event*
-enqueue_read_buffer(command_queue *cq, memory_object_holder *mem,
- void *buffer, size_t size, size_t device_offset,
- const clobj_t *wait_for, uint32_t num_wait_for,
- bool is_blocking)
-{
- auto _wait_for = buf_from_class<event>(wait_for, num_wait_for);
- cl_event evt;
- retry_mem_error<void>([&] {
- pyopencl_call_guarded(clEnqueueReadBuffer, cq->data(), mem->data(),
- cast_bool(is_blocking), device_offset, size,
- buffer, num_wait_for, _wait_for.get(), &evt);
- });
- return new_event(evt);
}
-inline event*
-enqueue_copy_buffer(command_queue *cq, memory_object_holder *src,
- memory_object_holder *dst, ptrdiff_t byte_count,
- size_t src_offset, size_t dst_offset,
- const clobj_t *wait_for, uint32_t num_wait_for)
-{
- if (byte_count < 0) {
- size_t byte_count_src = 0;
- size_t byte_count_dst = 0;
- pyopencl_call_guarded(clGetMemObjectInfo, src->data(), CL_MEM_SIZE,
- sizeof(byte_count), &byte_count_src, NULL);
- pyopencl_call_guarded(clGetMemObjectInfo, src->data(), CL_MEM_SIZE,
- sizeof(byte_count), &byte_count_dst, NULL);
- byte_count = std::min(byte_count_src, byte_count_dst);
- }
- auto _wait_for = buf_from_class<event>(wait_for, num_wait_for);
- cl_event evt;
- retry_mem_error<void>([&] {
- pyopencl_call_guarded(clEnqueueCopyBuffer, cq->data(), src->data(),
- dst->data(), src_offset, dst_offset,
- byte_count, num_wait_for,
- _wait_for.get(), &evt);
- });
- return new_event(evt);
-}
-inline event*
-enqueue_write_buffer(command_queue *cq, memory_object_holder *mem,
- const void *buffer, size_t size, size_t device_offset,
- const clobj_t *wait_for, uint32_t num_wait_for,
- bool is_blocking)
-{
- auto _wait_for = buf_from_class<event>(wait_for, num_wait_for);
- cl_event evt;
- retry_mem_error<void>([&] {
- pyopencl_call_guarded(clEnqueueWriteBuffer, cq->data(), mem->data(),
- cast_bool(is_blocking), device_offset,
- size, buffer, num_wait_for,
- _wait_for.get(), &evt);
- });
- return new_event(evt);
- //PYOPENCL_RETURN_NEW_NANNY_EVENT(evt, buffer);
-}
-
-// }}}
-
-inline event*
-enqueue_nd_range_kernel(command_queue *cq, kernel *knl, cl_uint work_dim,
- const size_t *global_work_offset,
- const size_t *global_work_size,
- const size_t *local_work_size,
- const clobj_t *wait_for, uint32_t num_wait_for)
-{
- auto _wait_for = buf_from_class<event>(wait_for, num_wait_for);
- cl_event evt;
- retry_mem_error<void>([&] {
- pyopencl_call_guarded(clEnqueueNDRangeKernel, cq->data(),
- knl->data(), work_dim, global_work_offset,
- global_work_size, local_work_size,
- num_wait_for, _wait_for.get(), &evt);
- });
- return new_event(evt);
-}
+// {{{ c wrapper
-#if PYOPENCL_CL_VERSION >= 0x1020
-inline event*
-enqueue_marker_with_wait_list(command_queue *cq, const clobj_t *wait_for,
- uint32_t num_wait_for)
-{
- auto _wait_for = buf_from_class<event>(wait_for, num_wait_for);
- cl_event evt;
- pyopencl_call_guarded(clEnqueueMarkerWithWaitList, cq->data(),
- num_wait_for, _wait_for.get(), &evt);
- return new_event(evt);
-}
+// Import all the names in pyopencl namespace for c wrappers.
+using namespace pyopencl;
-inline event*
-enqueue_barrier_with_wait_list(command_queue *cq, const clobj_t *wait_for,
- uint32_t num_wait_for)
+// Generic functions
+int
+get_cl_version()
{
- auto _wait_for = buf_from_class<event>(wait_for, num_wait_for);
- cl_event evt;
- pyopencl_call_guarded(clEnqueueBarrierWithWaitList, cq->data(),
- num_wait_for, _wait_for.get(), &evt);
- return new_event(evt);
+ return PYOPENCL_CL_VERSION;
}
-#endif
-inline event*
-enqueue_marker(command_queue *cq)
+void
+free_pointer(void *p)
{
- cl_event evt;
- pyopencl_call_guarded(clEnqueueMarker, cq->data(), &evt);
- return new_event(evt);
+ free(p);
}
-inline void
-enqueue_barrier(command_queue *cq)
+void
+free_pointer_array(void **p, uint32_t size)
{
- pyopencl_call_guarded(clEnqueueBarrier, cq->data());
-}
+ for (uint32_t i = 0;i < size;i++) {
+ free(p[i]);
+ }
}
-
-// {{{ c wrapper
-
-void pyopencl_free_pointer(void *p)
+void
+set_gc(int (*func)())
{
- free(p);
+ python_gc = func ? func : dummy_python_gc;
}
-void pyopencl_free_pointer_array(void **p, uint32_t size)
+int have_gl()
{
- for (uint32_t i = 0;i < size;i++) {
- pyopencl_free_pointer(p[i]);
- }
+#ifdef HAVE_GL
+ return 1;
+#else
+ return 0;
+#endif
}
-void
-pyopencl_set_gc(int (*func)())
-{
- if (!func)
- func = pyopencl::dummy_python_gc;
- pyopencl::python_gc = func;
-}
-::error*
-get_platforms(clobj_t **ptr_platforms, uint32_t *num_platforms)
+// Platform
+error*
+get_platforms(clobj_t **_platforms, uint32_t *num_platforms)
{
- return pyopencl::c_handle_error([&] {
+ return c_handle_error([&] {
*num_platforms = 0;
pyopencl_call_guarded(clGetPlatformIDs, 0, NULL, num_platforms);
pyopencl_buf<cl_platform_id> platforms(*num_platforms);
pyopencl_call_guarded(clGetPlatformIDs, *num_platforms,
platforms.get(), num_platforms);
- *ptr_platforms =
- pyopencl::buf_to_base<pyopencl::platform>(platforms).release();
+ *_platforms = buf_to_base<platform>(platforms).release();
});
}
-
-::error*
-platform__get_devices(clobj_t platform, clobj_t **ptr_devices,
+error*
+platform__get_devices(clobj_t _plat, clobj_t **_devices,
uint32_t *num_devices, cl_device_type devtype)
{
- return pyopencl::c_handle_error([&] {
- auto devices = static_cast<pyopencl::platform*>(platform)
- ->get_devices(devtype);
+ auto plat = static_cast<platform*>(_plat);
+ return c_handle_error([&] {
+ auto devices = plat->get_devices(devtype);
*num_devices = devices.len();
- *ptr_devices =
- pyopencl::buf_to_base<pyopencl::device>(devices).release();
+ *_devices = buf_to_base<device>(devices).release();
});
}
-::error*
-_create_context(clobj_t *ptr_ctx, const cl_context_properties *properties,
- cl_uint num_devices, const clobj_t *ptr_devices)
+// Context
+error*
+create_context(clobj_t *_ctx, const cl_context_properties *properties,
+ cl_uint num_devices, const clobj_t *_devices)
{
- return pyopencl::c_handle_error([&] {
- auto devices = pyopencl::buf_from_class<pyopencl::device>(
- ptr_devices, num_devices);
- *ptr_ctx = new pyopencl::context(
+ return c_handle_error([&] {
+ auto devices = buf_from_class<device>(_devices, num_devices);
+ *_ctx = new context(
pyopencl_call_guarded(
clCreateContext,
const_cast<cl_context_properties*>(properties),
@@ -2093,475 +1888,530 @@ _create_context(clobj_t *ptr_ctx, const cl_context_properties *properties,
});
}
-
-::error*
-_create_command_queue(clobj_t *queue, clobj_t context,
- clobj_t device, cl_command_queue_properties properties)
+error*
+context__get_supported_image_formats(clobj_t _ctx, cl_mem_flags flags,
+ cl_mem_object_type image_type,
+ generic_info *out)
{
- auto ctx = static_cast<pyopencl::context*>(context);
- auto dev = static_cast<pyopencl::device*>(device);
- return pyopencl::c_handle_error([&] {
- *queue = new pyopencl::command_queue(ctx, dev, properties);
+ auto ctx = static_cast<context*>(_ctx);
+ return c_handle_error([&] {
+ *out = ctx->get_supported_image_formats(flags, image_type);
});
}
-::error*
-_create_buffer(clobj_t *buffer, clobj_t context, cl_mem_flags flags,
- size_t size, void *hostbuf)
+// Command Queue
+error*
+create_command_queue(clobj_t *queue, clobj_t _ctx,
+ clobj_t _dev, cl_command_queue_properties properties)
{
- auto ctx = static_cast<pyopencl::context*>(context);
- return pyopencl::c_handle_error([&] {
- *buffer = create_buffer(ctx, flags, size, hostbuf);
+ auto ctx = static_cast<context*>(_ctx);
+ auto dev = static_cast<device*>(_dev);
+ return c_handle_error([&] {
+ *queue = new command_queue(ctx, dev, properties);
});
}
-// {{{ program
-
-::error*
-_create_program_with_source(clobj_t *program, clobj_t context, const char *src)
+error*
+command_queue__finish(clobj_t queue)
{
- auto ctx = static_cast<pyopencl::context*>(context);
- return pyopencl::c_handle_error([&] {
- *program = create_program_with_source(ctx, src);
+ return c_handle_error([&] {
+ static_cast<command_queue*>(queue)->finish();
});
}
-::error*
-_create_program_with_binary(
- clobj_t *program, clobj_t context, cl_uint num_devices,
- const clobj_t *devices, cl_uint num_binaries, char **binaries,
- size_t *binary_sizes)
+error*
+command_queue__flush(clobj_t queue)
{
- auto ctx = static_cast<pyopencl::context*>(context);
- return pyopencl::c_handle_error([&] {
- *program = create_program_with_binary(
- ctx, num_devices, devices,
- num_binaries, binaries, binary_sizes);
+ return c_handle_error([&] {
+ static_cast<command_queue*>(queue)->flush();
});
}
-::error*
-program__build(clobj_t program, const char *options,
- cl_uint num_devices, const clobj_t *devices)
-{
- return pyopencl::c_handle_error([&] {
- static_cast<pyopencl::program*>(program)->build(
- options, num_devices, devices);
+
+// Buffer
+error*
+create_buffer(clobj_t *buffer, clobj_t _ctx, cl_mem_flags flags,
+ size_t size, void *hostbuf)
+{
+ auto ctx = static_cast<context*>(_ctx);
+ return c_handle_error([&] {
+ auto mem = retry_mem_error<cl_mem>([&] {
+ return pyopencl_call_guarded(clCreateBuffer, ctx->data(),
+ flags, size, hostbuf);
+ });
+ *buffer = new_buffer(mem, (flags & CL_MEM_USE_HOST_PTR ?
+ hostbuf : NULL));
});
}
-::error*
-program__kind(clobj_t program, int *kind)
+
+// Memory Object
+error*
+memory_object__release(clobj_t obj)
{
- return pyopencl::c_handle_error([&] {
- *kind = static_cast<pyopencl::program*>(program)->kind();
+ return c_handle_error([&] {
+ static_cast<memory_object*>(obj)->release();
});
}
-::error*
-program__get_build_info(clobj_t program, clobj_t device,
- cl_program_build_info param, generic_info *out)
-{
- return pyopencl::c_handle_error([&] {
- *out = static_cast<pyopencl::program*>(program)
- ->get_build_info(
- static_cast<pyopencl::device*>(device), param);
+// Program
+error*
+create_program_with_source(clobj_t *prog, clobj_t _ctx, const char *src)
+{
+ auto ctx = static_cast<context*>(_ctx);
+ return c_handle_error([&] {
+ size_t length = strlen(src);
+ cl_program result = pyopencl_call_guarded(
+ clCreateProgramWithSource, ctx->data(), 1, &src, &length);
+ *prog = new_program(result, KND_SOURCE);
});
}
-// }}}
-
-::error*
-_create_sampler(clobj_t *sampler, clobj_t context, int normalized_coordinates,
- cl_addressing_mode am, cl_filter_mode fm)
+error*
+create_program_with_binary(clobj_t *prog, clobj_t _ctx,
+ cl_uint num_devices, const clobj_t *devices,
+ char **binaries, size_t *binary_sizes)
{
- return pyopencl::c_handle_error([&] {
- *sampler = new pyopencl::sampler(
- static_cast<pyopencl::context*>(context),
- (bool)normalized_coordinates, am, fm);
+ auto ctx = static_cast<context*>(_ctx);
+ auto devs = buf_from_class<device>(devices, num_devices);
+ pyopencl_buf<cl_int> binary_statuses(num_devices);
+ return c_handle_error([&] {
+ cl_program result = pyopencl_call_guarded(
+ clCreateProgramWithBinary, ctx->data(), num_devices, devs.get(),
+ binary_sizes, reinterpret_cast<const unsigned char**>(
+ const_cast<const char**>(binaries)), binary_statuses.get());
+ // for (cl_uint i = 0; i < num_devices; ++i)
+ // std::cout << i << ":" << binary_statuses[i] << std::endl;
+ *prog = new_program(result, KND_BINARY);
});
}
-// {{{ event
+error*
+program__build(clobj_t _prog, const char *options,
+ cl_uint num_devices, const clobj_t *devices)
+{
+ auto prog = static_cast<program*>(_prog);
+ return c_handle_error([&] {
+ prog->build(options, num_devices, devices);
+ });
+}
-::error*
-event__get_profiling_info(clobj_t event, cl_profiling_info param,
- generic_info *out)
+error*
+program__kind(clobj_t prog, int *kind)
{
- return pyopencl::c_handle_error([&] {
- *out = static_cast<pyopencl::event*>(event)
- ->get_profiling_info(param);
+ return c_handle_error([&] {
+ *kind = static_cast<program*>(prog)->kind();
});
}
-::error*
-event__wait(clobj_t event)
+error*
+program__get_build_info(clobj_t _prog, clobj_t _dev,
+ cl_program_build_info param, generic_info *out)
{
- return pyopencl::c_handle_error([&] {
- static_cast<pyopencl::event*>(event)->wait();
+ auto prog = static_cast<program*>(_prog);
+ auto dev = static_cast<device*>(_dev);
+ return c_handle_error([&] {
+ *out = prog->get_build_info(dev, param);
});
}
-// }}}
+// Sampler
+error*
+create_sampler(clobj_t *samp, clobj_t _ctx, int norm_coords,
+ cl_addressing_mode am, cl_filter_mode fm)
+{
+ auto ctx = static_cast<context*>(_ctx);
+ return c_handle_error([&] {
+ *samp = new sampler(ctx, (bool)norm_coords, am, fm);
+ });
+}
-// {{{ kernel
-::error*
-_create_kernel(clobj_t *kernel, clobj_t program, const char *name)
+// Kernel
+error*
+create_kernel(clobj_t *knl, clobj_t _prog, const char *name)
{
- auto prg = static_cast<pyopencl::program*>(program);
- return pyopencl::c_handle_error([&] {
- *kernel = new pyopencl::kernel(prg, name);
+ auto prog = static_cast<program*>(_prog);
+ return c_handle_error([&] {
+ *knl = new kernel(prog, name);
});
}
-::error*
-kernel__set_arg_null(clobj_t kernel, cl_uint arg_index)
+error*
+kernel__set_arg_null(clobj_t knl, cl_uint arg_index)
{
- return pyopencl::c_handle_error([&] {
- static_cast<pyopencl::kernel*>(kernel)->set_arg_null(arg_index);
+ return c_handle_error([&] {
+ static_cast<kernel*>(knl)->set_arg_null(arg_index);
});
}
-::error*
-kernel__set_arg_mem(clobj_t kernel, cl_uint arg_index, clobj_t _mem)
+error*
+kernel__set_arg_mem(clobj_t _knl, cl_uint arg_index, clobj_t _mem)
{
- auto mem = static_cast<pyopencl::memory_object_holder*>(_mem);
- return pyopencl::c_handle_error([&] {
- static_cast<pyopencl::kernel*>(kernel)
- ->set_arg_mem(arg_index, mem);
+ auto knl = static_cast<kernel*>(_knl);
+ auto mem = static_cast<memory_object_holder*>(_mem);
+ return c_handle_error([&] {
+ knl->set_arg_mem(arg_index, mem);
});
}
-::error*
-kernel__set_arg_sampler(clobj_t kernel, cl_uint arg_index, clobj_t sampler)
+error*
+kernel__set_arg_sampler(clobj_t _knl, cl_uint arg_index, clobj_t _samp)
{
- return pyopencl::c_handle_error([&] {
- static_cast<pyopencl::kernel*>(kernel)
- ->set_arg_sampler(arg_index,
- static_cast<pyopencl::sampler*>(sampler));
+ auto knl = static_cast<kernel*>(_knl);
+ auto samp = static_cast<sampler*>(_samp);
+ return c_handle_error([&] {
+ knl->set_arg_sampler(arg_index, samp);
});
}
-::error*
-kernel__set_arg_buf(clobj_t kernel, cl_uint arg_index,
+error*
+kernel__set_arg_buf(clobj_t _knl, cl_uint arg_index,
const void *buffer, size_t size)
{
- return pyopencl::c_handle_error([&] {
- static_cast<pyopencl::kernel*>(kernel)
- ->set_arg_buf(arg_index, buffer, size);
+ auto knl = static_cast<kernel*>(_knl);
+ return c_handle_error([&] {
+ knl->set_arg_buf(arg_index, buffer, size);
});
}
-
-::error*
-kernel__get_work_group_info(clobj_t kernel, cl_kernel_work_group_info param,
- clobj_t device, generic_info *out)
+error*
+kernel__get_work_group_info(clobj_t _knl, cl_kernel_work_group_info param,
+ clobj_t _dev, generic_info *out)
{
- return pyopencl::c_handle_error([&] {
- *out = static_cast<pyopencl::kernel*>(kernel)
- ->get_work_group_info(param, static_cast<pyopencl::device*>(
- device));
+ auto knl = static_cast<kernel*>(_knl);
+ auto dev = static_cast<device*>(_dev);
+ return c_handle_error([&] {
+ *out = knl->get_work_group_info(param, dev);
});
}
-// }}}
-
-// {{{ image
+// Image
+error*
+create_image_2d(clobj_t *img, clobj_t _ctx, cl_mem_flags flags,
+ cl_image_format *fmt, size_t width, size_t height,
+ size_t pitch, void *buffer)
+{
+ auto ctx = static_cast<context*>(_ctx);
+ return c_handle_error([&] {
+ auto mem = retry_mem_error<cl_mem>([&] {
+ return pyopencl_call_guarded(
+ clCreateImage2D, ctx->data(), flags,
+ fmt, width, height, pitch, buffer);
+ });
+ *img = new_image(mem, (flags & CL_MEM_USE_HOST_PTR ?
+ buffer : NULL));
+ });
+}
-::error*
-_get_supported_image_formats(clobj_t context, cl_mem_flags flags,
- cl_mem_object_type image_type, generic_info *out)
-{
- return pyopencl::c_handle_error([&] {
- *out = get_supported_image_formats(
- static_cast<pyopencl::context*>(context), flags, image_type);
+error*
+create_image_3d(clobj_t *img, clobj_t _ctx, cl_mem_flags flags,
+ cl_image_format *fmt, size_t width, size_t height,
+ size_t depth, size_t pitch_x, size_t pitch_y, void *buffer)
+{
+ auto ctx = static_cast<context*>(_ctx);
+ return c_handle_error([&] {
+ auto mem = retry_mem_error<cl_mem>([&] {
+ return pyopencl_call_guarded(
+ clCreateImage3D, ctx->data(), flags, fmt, width,
+ height, depth, pitch_x, pitch_y, buffer);
+ });
+ *img = new_image(mem, (flags & CL_MEM_USE_HOST_PTR ?
+ buffer : NULL));
});
}
-::error*
-_create_image_2d(clobj_t *image, clobj_t context, cl_mem_flags flags,
- cl_image_format *fmt, size_t width, size_t height,
- size_t pitch, void *buffer, size_t size)
+error*
+image__get_image_info(clobj_t img, cl_image_info param, generic_info *out)
{
- return pyopencl::c_handle_error([&] {
- *image = create_image_2d(
- static_cast<pyopencl::context*>(context), flags, fmt,
- width, height, pitch, buffer, size);
+ return c_handle_error([&] {
+ *out = static_cast<image*>(img)->get_image_info(param);
});
}
-::error*
-_create_image_3d(clobj_t *image, clobj_t context, cl_mem_flags flags,
- cl_image_format *fmt, size_t width, size_t height,
- size_t depth, size_t pitch_x, size_t pitch_y,
- void *buffer, size_t size)
+
+// Event
+error*
+event__get_profiling_info(clobj_t _evt, cl_profiling_info param,
+ generic_info *out)
{
- return pyopencl::c_handle_error([&] {
- *image = create_image_3d(
- static_cast<pyopencl::context*>(context), flags, fmt,
- width, height, depth, pitch_x, pitch_y, buffer, size);
+ auto evt = static_cast<event*>(_evt);
+ return c_handle_error([&] {
+ *out = evt->get_profiling_info(param);
});
}
-::error*
-image__get_image_info(clobj_t image, cl_image_info param, generic_info *out)
+error*
+event__wait(clobj_t evt)
{
- return pyopencl::c_handle_error([&] {
- *out = static_cast<pyopencl::image*>(image)->get_image_info(param);
+ return c_handle_error([&] {
+ static_cast<event*>(evt)->wait();
});
}
-// }}}
-::error*
-_enqueue_nd_range_kernel(clobj_t *event, clobj_t queue, clobj_t kernel,
- cl_uint work_dim, const size_t *global_work_offset,
- const size_t *global_work_size,
- const size_t *local_work_size,
- const clobj_t *wait_for, uint32_t num_wait_for)
-{
- return pyopencl::c_handle_error([&] {
- *event = enqueue_nd_range_kernel(
- static_cast<pyopencl::command_queue*>(queue),
- static_cast<pyopencl::kernel*>(kernel),
- work_dim, global_work_offset,
- global_work_size, local_work_size,
- wait_for, num_wait_for);
+// enqueue_*
+error*
+enqueue_nd_range_kernel(clobj_t *_evt, clobj_t _queue, clobj_t _knl,
+ cl_uint work_dim, const size_t *global_work_offset,
+ const size_t *global_work_size,
+ const size_t *local_work_size,
+ const clobj_t *_wait_for, uint32_t num_wait_for)
+{
+ auto queue = static_cast<command_queue*>(_queue);
+ auto knl = static_cast<kernel*>(_knl);
+ return c_handle_error([&] {
+ auto wait_for = buf_from_class<event>(_wait_for, num_wait_for);
+ cl_event evt;
+ retry_mem_error<void>([&] {
+ pyopencl_call_guarded(
+ clEnqueueNDRangeKernel, queue->data(), knl->data(),
+ work_dim, global_work_offset, global_work_size,
+ local_work_size, num_wait_for, wait_for.get(), &evt);
+ });
+ *_evt = new_event(evt);
});
}
#if PYOPENCL_CL_VERSION >= 0x1020
-::error*
-_enqueue_marker_with_wait_list(clobj_t *event, clobj_t queue,
- const clobj_t *wait_for, uint32_t num_wait_for)
-{
- return pyopencl::c_handle_error([&] {
- *event = enqueue_marker_with_wait_list(
- static_cast<pyopencl::command_queue*>(queue),
- wait_for, num_wait_for);
+error*
+enqueue_marker_with_wait_list(clobj_t *_evt, clobj_t _queue,
+ const clobj_t *_wait_for, uint32_t num_wait_for)
+{
+ auto queue = static_cast<command_queue*>(_queue);
+ auto wait_for = buf_from_class<event>(_wait_for, num_wait_for);
+ return c_handle_error([&] {
+ cl_event evt;
+ pyopencl_call_guarded(clEnqueueMarkerWithWaitList, queue->data(),
+ num_wait_for, wait_for.get(), &evt);
+ *_evt = new_event(evt);
});
}
-::error*
-_enqueue_barrier_with_wait_list(clobj_t *event, clobj_t queue,
- const clobj_t *wait_for, uint32_t num_wait_for)
-{
- return pyopencl::c_handle_error([&] {
- *event = enqueue_barrier_with_wait_list(
- static_cast<pyopencl::command_queue*>(queue),
- wait_for, num_wait_for);
+error*
+enqueue_barrier_with_wait_list(clobj_t *_evt, clobj_t _queue,
+ const clobj_t *_wait_for, uint32_t num_wait_for)
+{
+ auto queue = static_cast<command_queue*>(_queue);
+ auto wait_for = buf_from_class<event>(_wait_for, num_wait_for);
+ return c_handle_error([&] {
+ cl_event evt;
+ pyopencl_call_guarded(clEnqueueBarrierWithWaitList, queue->data(),
+ num_wait_for, wait_for.get(), &evt);
+ *_evt = new_event(evt);
});
}
#endif
-::error*
-_enqueue_marker(clobj_t *event, clobj_t queue)
+error*
+enqueue_marker(clobj_t *_evt, clobj_t _queue)
{
- return pyopencl::c_handle_error([&] {
- *event = enqueue_marker(
- static_cast<pyopencl::command_queue*>(queue));
+ auto queue = static_cast<command_queue*>(_queue);
+ return c_handle_error([&] {
+ cl_event evt;
+ pyopencl_call_guarded(clEnqueueMarker, queue->data(), &evt);
+ *_evt = new_event(evt);
});
}
-::error*
-_enqueue_barrier(clobj_t queue)
+error*
+enqueue_barrier(clobj_t _queue)
{
- return pyopencl::c_handle_error([&] {
- enqueue_barrier(static_cast<pyopencl::command_queue*>(queue));
+ auto queue = static_cast<command_queue*>(_queue);
+ return c_handle_error([&] {
+ pyopencl_call_guarded(clEnqueueBarrier, queue->data());
});
}
// {{{ transfer enqueues
-::error*
-_enqueue_read_buffer(clobj_t *event, clobj_t queue, clobj_t mem,
- void *buffer, size_t size, size_t device_offset,
- const clobj_t *wait_for, uint32_t num_wait_for,
- int is_blocking)
+error*
+enqueue_read_buffer(clobj_t *_evt, clobj_t _queue, clobj_t _mem,
+ void *buffer, size_t size, size_t device_offset,
+ const clobj_t *_wait_for, uint32_t num_wait_for,
+ int is_blocking)
{
- return pyopencl::c_handle_error([&] {
- *event = enqueue_read_buffer(
- static_cast<pyopencl::command_queue*>(queue),
- static_cast<pyopencl::memory_object_holder*>(mem),
- buffer, size, device_offset, wait_for,
- num_wait_for, (bool)is_blocking);
+ auto wait_for = buf_from_class<event>(_wait_for, num_wait_for);
+ auto queue = static_cast<command_queue*>(_queue);
+ auto mem = static_cast<memory_object_holder*>(_mem);
+ return c_handle_error([&] {
+ cl_event evt;
+ retry_mem_error<void>([&] {
+ pyopencl_call_guarded(
+ clEnqueueReadBuffer, queue->data(), mem->data(),
+ cast_bool(is_blocking), device_offset, size,
+ buffer, num_wait_for, wait_for.get(), &evt);
+ });
+ *_evt = new_event(evt);
});
}
-::error*
-_enqueue_write_buffer(clobj_t *event, clobj_t queue, clobj_t mem,
- const void *buffer, size_t size, size_t device_offset,
- const clobj_t *wait_for, uint32_t num_wait_for,
- int is_blocking)
+error*
+enqueue_write_buffer(clobj_t *_evt, clobj_t _queue, clobj_t _mem,
+ const void *buffer, size_t size, size_t device_offset,
+ const clobj_t *_wait_for, uint32_t num_wait_for,
+ int is_blocking)
{
- return pyopencl::c_handle_error([&] {
- *event = enqueue_write_buffer(
- static_cast<pyopencl::command_queue*>(queue),
- static_cast<pyopencl::memory_object_holder*>(mem),
- buffer, size, device_offset, wait_for,
- num_wait_for, (bool)is_blocking);
+ auto wait_for = buf_from_class<event>(_wait_for, num_wait_for);
+ auto queue = static_cast<command_queue*>(_queue);
+ auto mem = static_cast<memory_object_holder*>(_mem);
+ return c_handle_error([&] {
+ cl_event evt;
+ retry_mem_error<void>([&] {
+ pyopencl_call_guarded(
+ clEnqueueWriteBuffer, queue->data(), mem->data(),
+ cast_bool(is_blocking), device_offset,
+ size, buffer, num_wait_for, wait_for.get(), &evt);
+ });
+ *_evt = new_event(evt);
+ // PYOPENCL_RETURN_NEW_NANNY_EVENT(evt, buffer);
});
}
-
-::error*
-_enqueue_copy_buffer(clobj_t *event, clobj_t queue, clobj_t src, clobj_t dst,
- ptrdiff_t byte_count, size_t src_offset, size_t dst_offset,
- const clobj_t *wait_for, uint32_t num_wait_for)
-{
- return pyopencl::c_handle_error([&] {
- *event = enqueue_copy_buffer(
- static_cast<pyopencl::command_queue*>(queue),
- static_cast<pyopencl::memory_object_holder*>(src),
- static_cast<pyopencl::memory_object_holder*>(dst),
- byte_count, src_offset, dst_offset, wait_for, num_wait_for);
+error*
+enqueue_copy_buffer(clobj_t *_evt, clobj_t _queue, clobj_t _src, clobj_t _dst,
+ ptrdiff_t byte_count, size_t src_offset, size_t dst_offset,
+ const clobj_t *_wait_for, uint32_t num_wait_for)
+{
+ auto queue = static_cast<command_queue*>(_queue);
+ auto src = static_cast<memory_object_holder*>(_src);
+ auto dst = static_cast<memory_object_holder*>(_dst);
+ return c_handle_error([&] {
+ if (byte_count < 0) {
+ size_t byte_count_src = 0;
+ size_t byte_count_dst = 0;
+ pyopencl_call_guarded(
+ clGetMemObjectInfo, src->data(), CL_MEM_SIZE,
+ sizeof(byte_count), &byte_count_src, NULL);
+ pyopencl_call_guarded(
+ clGetMemObjectInfo, src->data(), CL_MEM_SIZE,
+ sizeof(byte_count), &byte_count_dst, NULL);
+ byte_count = std::min(byte_count_src, byte_count_dst);
+ }
+ auto wait_for = buf_from_class<event>(_wait_for, num_wait_for);
+ cl_event evt;
+ retry_mem_error<void>([&] {
+ pyopencl_call_guarded(
+ clEnqueueCopyBuffer, queue->data(), src->data(),
+ dst->data(), src_offset, dst_offset, byte_count,
+ num_wait_for, wait_for.get(), &evt);
+ });
+ *_evt = new_event(evt);
});
}
-::error*
-_enqueue_read_image(clobj_t *event, clobj_t queue, clobj_t mem,
- size_t *origin, size_t *region, void *buffer, size_t size,
- size_t row_pitch, size_t slice_pitch,
- const clobj_t *wait_for, uint32_t num_wait_for,
- int is_blocking)
-{
- return pyopencl::c_handle_error([&] {
- *event = enqueue_read_image(
- static_cast<pyopencl::command_queue*>(queue),
- static_cast<pyopencl::image*>(mem),
- origin, region, buffer, size, row_pitch, slice_pitch,
- wait_for, num_wait_for, (bool)is_blocking);
+error*
+enqueue_read_image(clobj_t *_evt, clobj_t _queue, clobj_t _mem, size_t *origin,
+ size_t *region, void *buffer, size_t row_pitch,
+ size_t slice_pitch, const clobj_t *_wait_for,
+ uint32_t num_wait_for, int is_blocking)
+{
+ auto wait_for = buf_from_class<event>(_wait_for, num_wait_for);
+ auto queue = static_cast<command_queue*>(_queue);
+ auto img = static_cast<image*>(_mem);
+ return c_handle_error([&] {
+ cl_event evt;
+ retry_mem_error<void>([&] {
+ pyopencl_call_guarded(
+ clEnqueueReadImage, queue->data(), img->data(),
+ cast_bool(is_blocking), origin, region, row_pitch,
+ slice_pitch, buffer, num_wait_for,
+ wait_for.get(), &evt);
+ });
+ *_evt = new_event(evt);
+ //PYOPENCL_RETURN_NEW_NANNY_EVENT(evt, buffer);
});
}
// }}}
-::error*
-_command_queue_finish(clobj_t queue)
-{
- return pyopencl::c_handle_error([&] {
- static_cast<pyopencl::command_queue*>(queue)->finish();
- });
-}
-
-::error*
-_command_queue_flush(clobj_t queue)
-{
- return pyopencl::c_handle_error([&] {
- static_cast<pyopencl::command_queue*>(queue)->flush();
- });
-}
-
intptr_t
-_int_ptr(clobj_t obj)
+clobj__int_ptr(clobj_t obj)
{
return obj->intptr();
}
-::error*
+error*
_from_int_ptr(clobj_t *ptr_out, intptr_t int_ptr_value, class_t class_)
{
#define FROM_INT_PTR(CLSU, CLS) \
- *ptr_out = new pyopencl::CLS((PYOPENCL_CL_##CLSU)int_ptr_value, \
+ *ptr_out = new CLS((PYOPENCL_CL_##CLSU)int_ptr_value, \
/* retain */ true);
- return pyopencl::c_handle_error([&] {
+ return c_handle_error([&] {
SWITCHCLASS(FROM_INT_PTR);
});
}
-::error*
-_get_info(clobj_t obj, cl_uint param, generic_info *out)
+error*
+clobj__get_info(clobj_t obj, cl_uint param, generic_info *out)
{
- return pyopencl::c_handle_error([&] {
+ return c_handle_error([&] {
*out = obj->get_info(param);
});
}
void
-_delete(clobj_t obj)
+clobj__delete(clobj_t obj)
{
delete obj;
}
-::error*
-_release_memobj(clobj_t obj)
-{
- return pyopencl::c_handle_error([&] {
- static_cast<pyopencl::memory_object*>(obj)->release();
- });
-}
-
-int pyopencl_get_cl_version()
-{
- return PYOPENCL_CL_VERSION;
-}
-
// {{{ gl interop
-int pyopencl_have_gl()
-{
-#ifdef HAVE_GL
- return 1;
-#else
- return 0;
-#endif
-}
-
#ifdef HAVE_GL
error*
-_create_from_gl_buffer(clobj_t *ptr, clobj_t context,
- cl_mem_flags flags, GLuint bufobj)
+create_from_gl_buffer(clobj_t *ptr, clobj_t _ctx,
+ cl_mem_flags flags, GLuint bufobj)
{
- auto ctx = static_cast<pyopencl::context*>(context);
- return pyopencl::c_handle_error([&] {
+ auto ctx = static_cast<context*>(_ctx);
+ return c_handle_error([&] {
cl_mem mem = pyopencl_call_guarded(clCreateFromGLBuffer,
ctx->data(), flags, bufobj);
- *ptr = pyopencl_convert_obj(pyopencl::gl_buffer,
+ *ptr = pyopencl_convert_obj(gl_buffer,
clReleaseMemObject, mem);
});
}
error*
-_create_from_gl_renderbuffer(clobj_t *ptr, clobj_t context,
- cl_mem_flags flags, GLuint bufobj)
+create_from_gl_renderbuffer(clobj_t *ptr, clobj_t _ctx,
+ cl_mem_flags flags, GLuint bufobj)
{
- auto ctx = static_cast<pyopencl::context*>(context);
- return pyopencl::c_handle_error([&] {
+ auto ctx = static_cast<context*>(_ctx);
+ return c_handle_error([&] {
cl_mem mem = pyopencl_call_guarded(clCreateFromGLRenderbuffer,
ctx->data(), flags, bufobj);
- *ptr = pyopencl_convert_obj(pyopencl::gl_renderbuffer,
+ *ptr = pyopencl_convert_obj(gl_renderbuffer,
clReleaseMemObject, mem);
});
}
-::error*
-_enqueue_acquire_gl_objects(clobj_t *event, clobj_t queue,
- const clobj_t *mem_objects,
- uint32_t num_mem_objects,
- const clobj_t *wait_for, uint32_t num_wait_for)
-{
- return pyopencl::c_handle_error([&] {
- *event = enqueue_gl_objects(
- Acquire, static_cast<pyopencl::command_queue*>(queue),
+error*
+enqueue_acquire_gl_objects(clobj_t *_evt, clobj_t queue,
+ const clobj_t *mem_objects,
+ uint32_t num_mem_objects,
+ const clobj_t *wait_for, uint32_t num_wait_for)
+{
+ return c_handle_error([&] {
+ *_evt = enqueue_gl_objects(
+ Acquire, static_cast<command_queue*>(queue),
mem_objects, num_mem_objects, wait_for, num_wait_for);
});
}
-::error*
-_enqueue_release_gl_objects(clobj_t *event, clobj_t queue,
- const clobj_t *mem_objects,
- uint32_t num_mem_objects,
- const clobj_t *wait_for, uint32_t num_wait_for)
+error*
+enqueue_release_gl_objects(clobj_t *event, clobj_t queue,
+ const clobj_t *mem_objects,
+ uint32_t num_mem_objects,
+ const clobj_t *wait_for, uint32_t num_wait_for)
{
- return pyopencl::c_handle_error([&] {
+ return c_handle_error([&] {
*event = enqueue_gl_objects(
- Release, static_cast<pyopencl::command_queue*>(queue),
+ Release, static_cast<command_queue*>(queue),
mem_objects, num_mem_objects, wait_for, num_wait_for);
});
}
--
GitLab