From 23e578fca3ee9e984cba049b0b2dadf5e8f10f05 Mon Sep 17 00:00:00 2001
From: Marko Bencun <mbencun@gmail.com>
Date: Sat, 31 Aug 2013 14:40:36 +0200
Subject: [PATCH] hashing
---
pyopencl/cache.py | 4 +-
pyopencl/cffi_cl.py | 54 +++++++++----
src/c_wrapper/wrap_cl.cpp | 143 ++++++++++++++++++++---------------
src/c_wrapper/wrap_cl.h | 3 +-
src/c_wrapper/wrap_cl_core.h | 55 +++++++-------
5 files changed, 153 insertions(+), 106 deletions(-)
diff --git a/pyopencl/cache.py b/pyopencl/cache.py
index 0db15d6e..10ea16e0 100644
--- a/pyopencl/cache.py
+++ b/pyopencl/cache.py
@@ -24,7 +24,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""
-import pyopencl._cl as _cl
+#import pyopencl._cl as _cl
+import pyopencl.cffi_cl as _cl
import re
import sys
import os
@@ -395,7 +396,6 @@ def _create_built_program_from_source_cached(ctx, src, options, devices, cache_d
from uuid import uuid4
src = src + "\n\n__constant int pyopencl_defeat_cache_%s = 0;" % (
uuid4().hex)
-
prg = _cl._Program(ctx, src)
prg.build(options, [devices[i] for i in to_be_built_indices])
diff --git a/pyopencl/cffi_cl.py b/pyopencl/cffi_cl.py
index 753bb3d7..d649de4a 100644
--- a/pyopencl/cffi_cl.py
+++ b/pyopencl/cffi_cl.py
@@ -1,4 +1,4 @@
-from pyopencl._cl import RuntimeError
+#from pyopencl._cl import RuntimeError
import warnings
@@ -79,7 +79,6 @@ typedef cl_uint cl_event_info;
typedef cl_uint cl_command_type;
typedef cl_uint cl_profiling_info;
-
"""
with open(os.path.join(current_directory, 'wrap_cl_core.h')) as _f:
@@ -95,11 +94,14 @@ _lib = _ffi.verify(
library_dirs=[current_directory],
libraries=["wrapcl", "OpenCL"])
-class PP(object):
+class _CArray(object):
def __init__(self, ptr):
self.ptr = ptr
self.size = _ffi.new('uint32_t *')
+ def __del__(self):
+ _lib._free(self.ptr[0])
+
def __getitem__(self, key):
return self.ptr[0].__getitem__(key)
@@ -107,8 +109,10 @@ class PP(object):
for i in xrange(self.size[0]):
yield self[i]
+class _CArrays(_CArray):
def __del__(self):
- _lib.freem(self.ptr[0])
+ _lib._free2(_ffi.cast('void**', self.ptr[0]), self.size[0])
+ super(_CArrays, self).__del__()
class CLRuntimeError(RuntimeError):
def __init__(self, routine, code, msg=""):
@@ -125,8 +129,6 @@ def get_cl_header_version():
return (v >> (3*4),
(v >> (1*4)) & 0xff)
-_CL_VERSION = get_cl_header_version()
-
# {{{ expose constants classes like platform_info, device_type, ...
_constants = {}
@_ffi.callback('void(const char*, const char* name, unsigned int value)')
@@ -184,7 +186,7 @@ def _parse_context_properties(properties):
return _ffi.new('cl_context_properties[]', props)
-class Context(object):
+class Context(EQUALITY_TESTS):
def __init__(self, devices=None, properties=None, dev_type=None):
c_props = _parse_context_properties(properties)
status_code = _ffi.new('cl_int *')
@@ -202,10 +204,13 @@ class Context(object):
self.ptr = ptr_ctx[0]
+ def __hash__(self):
+ return _lib.context__hash(self.ptr)
+
def get_info(self, param):
return 'TODO'
-class CommandQueue(object):
+class CommandQueue(EQUALITY_TESTS):
def __init__(self, context, device=None, properties=None):
if properties is None:
properties = 0
@@ -213,16 +218,22 @@ class CommandQueue(object):
_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 __hash__(self):
+ return _lib.command_queue__hash(self.ptr)
+
def get_info(self, param):
print param
raise NotImplementedError()
-class MemoryObjectHolder(object):
+class MemoryObjectHolder(EQUALITY_TESTS):
def get_info(self, param):
info = _ffi.new('generic_info *')
_lib.memory_object_holder__get_info(self.ptr, param, info)
return _generic_info_to_python(info)
+ def __hash__(self):
+ return _lib.memory_object_holder__hash(self.ptr)
+
class MemoryObject(MemoryObjectHolder):
pass
@@ -251,6 +262,9 @@ class _Program(object):
else:
self._init_binary(*args)
+ def __hash__(self):
+ return _lib.program__hash(self.ptr)
+
def int_ptr(self):
raise NotImplementedError()
@@ -290,7 +304,7 @@ class _Program(object):
def get_info(self, param):
if param == program_info.DEVICES:
# todo: refactor, same code as in get_devices
- devices = PP(_ffi.new('void**'))
+ devices = _CArray(_ffi.new('void**'))
_lib.program__get_info__devices(self.ptr, devices.ptr, devices.size)
result = []
for i in xrange(devices.size[0]):
@@ -299,17 +313,19 @@ class _Program(object):
result.append(_create_device(device_ptr))
return result
elif param == program_info.BINARIES:
- # TODO possible memory leak? the char arrays might not be freed
- ptr_binaries = PP(_ffi.new('char***'))
+ ptr_binaries = _CArrays(_ffi.new('char***'))
_lib.program__get_info__binaries(self.ptr, ptr_binaries.ptr, ptr_binaries.size)
return map(_ffi.string, ptr_binaries)
print param
raise NotImplementedError()
-class Platform(object):
+class Platform(EQUALITY_TESTS):
def __init__(self):
pass
+ def __hash__(self):
+ return _lib.platform__hash(self.ptr)
+
# todo: __del__
def get_info(self, param):
@@ -318,7 +334,7 @@ class Platform(object):
return _generic_info_to_python(info)
def get_devices(self, device_type=device_type.ALL):
- devices = PP(_ffi.new('void**'))
+ devices = _CArray(_ffi.new('void**'))
_lib.platform__get_devices(self.ptr, devices.ptr, devices.size, device_type)
result = []
for i in xrange(devices.size[0]):
@@ -351,6 +367,9 @@ class Kernel(object):
_lib._create_kernel(ptr_kernel, program.ptr, name)
self.ptr = ptr_kernel[0]
+ def __hash__(self):
+ return _lib.kernel__hash(self.ptr)
+
def get_info(self, param):
info = _ffi.new('generic_info *')
_lib.kernel__get_info(self.ptr, param, info)
@@ -364,7 +383,7 @@ class Kernel(object):
raise NotImplementedError()
def get_platforms():
- platforms = PP(_ffi.new('void**'))
+ platforms = _CArray(_ffi.new('void**'))
_lib.get_platforms(platforms.ptr, platforms.size)
result = []
for i in xrange(platforms.size[0]):
@@ -374,9 +393,12 @@ def get_platforms():
return result
-class Event(object):
+class Event(EQUALITY_TESTS):
def __init__(self):
pass
+
+ def __hash__(self):
+ return _lib.event__hash(self.ptr)
def get_info(self, param):
print param
diff --git a/src/c_wrapper/wrap_cl.cpp b/src/c_wrapper/wrap_cl.cpp
index 6322f237..3619fa9e 100644
--- a/src/c_wrapper/wrap_cl.cpp
+++ b/src/c_wrapper/wrap_cl.cpp
@@ -6,7 +6,7 @@
#include <string.h>
#include <memory>
-#define MALLOC(TYPE, VAR, N) TYPE* VAR = reinterpret_cast<TYPE*>(malloc(sizeof(TYPE)*(N)));
+#define MALLOC(TYPE, VAR, N) TYPE *VAR = reinterpret_cast<TYPE*>(malloc(sizeof(TYPE)*(N)));
// {{{ tracing and error reporting
#ifdef PYOPENCL_TRACE
@@ -173,7 +173,7 @@ int get_cl_version(void) {
extern "C"
namespace pyopencl
{
- char* _copy_str(const std::string& str) {
+ char *_copy_str(const std::string& str) {
MALLOC(char, cstr, str.size() + 1);
strcpy(cstr, str.c_str());
return cstr;
@@ -318,8 +318,7 @@ namespace pyopencl
return m_platform;
}
- // TODO
- // PYOPENCL_EQUALITY_TESTS(platform);
+ PYOPENCL_EQUALITY_TESTS(platform);
generic_info get_info(cl_platform_info param_name) const
{
@@ -754,7 +753,7 @@ namespace pyopencl
return m_context;
}
- //PYOPENCL_EQUALITY_TESTS(context);
+ PYOPENCL_EQUALITY_TESTS(context);
// py::object get_info(cl_context_info param_name) const
// {
@@ -900,7 +899,7 @@ namespace pyopencl
const cl_command_queue data() const
{ return m_queue; }
- // PYOPENCL_EQUALITY_TESTS(command_queue);
+ PYOPENCL_EQUALITY_TESTS(command_queue);
// py::object get_info(cl_command_queue_info param_name) const
// {
@@ -966,7 +965,7 @@ namespace pyopencl
public:
virtual const cl_mem data() const = 0;
- //PYOPENCL_EQUALITY_TESTS(memory_object_holder);
+ PYOPENCL_EQUALITY_TESTS(memory_object_holder);
size_t size() const
{
@@ -1030,10 +1029,10 @@ namespace pyopencl
private:
bool m_valid;
cl_mem m_mem;
- void* m_hostbuf;
+ void *m_hostbuf;
public:
- memory_object(cl_mem mem, bool retain, void* hostbuf=0)
+ memory_object(cl_mem mem, bool retain, void *hostbuf=0)
: m_valid(true), m_mem(mem)
{
if (retain)
@@ -1071,7 +1070,7 @@ namespace pyopencl
release();
}
- void* hostbuf()
+ void *hostbuf()
{ return m_hostbuf; }
const cl_mem data() const
@@ -1276,7 +1275,7 @@ class buffer : public memory_object
context &ctx,
cl_mem_flags flags,
size_t size,
- void* py_hostbuf
+ void *py_hostbuf
)
{
@@ -1339,7 +1338,7 @@ class buffer : public memory_object
return m_program_kind;
}
- //PYOPENCL_EQUALITY_TESTS(program);
+ PYOPENCL_EQUALITY_TESTS(program);
std::vector<cl_device_id> get_info__devices()
{
@@ -1348,7 +1347,7 @@ class buffer : public memory_object
return result;
}
- char** get_info__binaries(uint32_t *num_binaries) {
+ char **get_info__binaries(uint32_t *num_binaries) {
std::vector<size_t> sizes;
PYOPENCL_GET_VEC_INFO(Program, m_program, CL_PROGRAM_BINARY_SIZES, sizes);
@@ -1364,20 +1363,6 @@ class buffer : public memory_object
(m_program, CL_PROGRAM_BINARIES, sizes.size()*sizeof(char *),
result_ptrs, 0)); \
return result_ptrs;
-// py::list py_result;
-// ptr = result.get();
-// for (unsigned i = 0; i < sizes.size(); ++i) {
-// py::handle<> binary_pyobj(
-// #if PY_VERSION_HEX >= 0x03000000
-// PyBytes_FromStringAndSize(
-// reinterpret_cast<char *>(ptr), sizes[i])
-// #else
-// PyString_FromStringAndSize(
-// reinterpret_cast<char *>(ptr), sizes[i])
-// #endif
-// );
-// py_result.append(binary_pyobj);
-// ptr += sizes[i];
}
@@ -1496,7 +1481,7 @@ class buffer : public memory_object
// }
// }
- void build(char* options, cl_uint num_devices, void** ptr_devices)
+ void build(char *options, cl_uint num_devices, void **ptr_devices)
{
// todo: this function should get a list of device instances, not raw pointers
// pointers are for the cffi interface and should not be here
@@ -1782,7 +1767,7 @@ class buffer : public memory_object
event *enqueue_read_buffer(
command_queue &cq,
memory_object_holder &mem,
- void* buffer,
+ void *buffer,
size_t size,
size_t device_offset,
/*py::object py_wait_for,*/
@@ -1855,9 +1840,9 @@ 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 size_t *global_work_offset,
+ const size_t *global_work_size,
+ const size_t *local_work_size //,
//py::object py_global_work_offset,
//py::object py_wait_for,
)
@@ -1915,9 +1900,9 @@ inline event *enqueue_nd_range_kernel(
program *create_program_with_binary(
context &ctx,
cl_uint num_devices,
- void** ptr_devices,
+ void **ptr_devices,
cl_uint num_binaries,
- char** binaries)
+ char **binaries)
{
std::vector<cl_device_id> devices;
std::vector<size_t> sizes;
@@ -1960,7 +1945,7 @@ inline event *enqueue_nd_range_kernel(
- void* get_platforms(void** ptr_platforms, uint32_t *num_platforms) {
+ void *get_platforms(void **ptr_platforms, uint32_t *num_platforms) {
*num_platforms = 0;
PYOPENCL_CALL_GUARDED(clGetPlatformIDs, (0, 0, num_platforms));
@@ -1977,18 +1962,24 @@ inline event *enqueue_nd_range_kernel(
return 0;
}
- void freem(void* p) {
+ void _free(void *p) {
free(p);
}
- void* platform__get_info(void* ptr_platform, cl_platform_info param, generic_info* out) {
+ void _free2(void **p, uint32_t size) {
+ for(uint32_t i = 0; i < size; ++i) {
+ _free(p[i]);
+ }
+ }
+
+ void *platform__get_info(void *ptr_platform, cl_platform_info param, generic_info *out) {
// todo: catch error
*out = static_cast<platform*>(ptr_platform)->get_info(param);
//*out = _copy_str(static_cast<platform*>(ptr_platform)->get_info(param_name));
return 0;
}
- void* platform__get_devices(void* ptr_platform, void** ptr_devices, uint32_t* num_devices, cl_device_type devtype) {
+ void *platform__get_devices(void *ptr_platform, void **ptr_devices, uint32_t *num_devices, cl_device_type devtype) {
typedef std::vector<cl_device_id> vec;
// todo: catch error
@@ -2003,14 +1994,19 @@ inline event *enqueue_nd_range_kernel(
return 0;
}
+
+ long platform__hash(void *ptr_platform) {
+ return static_cast<platform*>(ptr_platform)->hash();
+ }
- void* device__get_info(void* ptr_device, cl_device_info param, generic_info* out) {
+
+ void *device__get_info(void *ptr_device, cl_device_info param, generic_info *out) {
// todo: catch error
*out = static_cast<device*>(ptr_device)->get_info(param);
return 0;
}
- void* _create_context(void** ptr_ctx, cl_context_properties* properties, cl_uint num_devices, void** ptr_devices) {
+ void *_create_context(void **ptr_ctx, cl_context_properties *properties, cl_uint num_devices, void **ptr_devices) {
cl_int status_code;
std::vector<cl_device_id> devices(num_devices);
@@ -2031,48 +2027,48 @@ inline event *enqueue_nd_range_kernel(
return 0;
}
- void* _create_command_queue(void** ptr_command_queue, void* ptr_context, void* ptr_device, cl_command_queue_properties properties) {
+ void *_create_command_queue(void **ptr_command_queue, void *ptr_context, void *ptr_device, cl_command_queue_properties properties) {
// todo error handling
- context* ctx = static_cast<context*>(ptr_context);
- device* dev = static_cast<device*>(ptr_device);
+ context *ctx = static_cast<context*>(ptr_context);
+ device *dev = static_cast<device*>(ptr_device);
*ptr_command_queue = new command_queue(*ctx, dev, properties);
return 0;
}
- void* _create_buffer(void** ptr_buffer, void* ptr_context, cl_mem_flags flags, size_t size, void* hostbuf) {
- context* ctx = static_cast<context*>(ptr_context);
+ void *_create_buffer(void **ptr_buffer, void *ptr_context, cl_mem_flags flags, size_t size, void *hostbuf) {
+ context *ctx = static_cast<context*>(ptr_context);
*ptr_buffer = create_buffer_py(*ctx, flags, size, hostbuf);
// todo error handling
return 0;
}
- void* _create_program_with_source(void **ptr_program, void *ptr_context, char* src) {
- context* ctx = static_cast<context*>(ptr_context);
+ void *_create_program_with_source(void **ptr_program, void *ptr_context, char *src) {
+ context *ctx = static_cast<context*>(ptr_context);
*ptr_program = create_program_with_source(*ctx, src);
// todo error handling
return 0;
}
- void* _create_program_with_binary(void **ptr_program, void *ptr_context, cl_uint num_devices, void** ptr_devices, cl_uint num_binaries, char** binaries) {
+ void *_create_program_with_binary(void **ptr_program, void *ptr_context, cl_uint num_devices, void **ptr_devices, cl_uint num_binaries, char **binaries) {
// todo: catch error
- context* ctx = static_cast<context*>(ptr_context);
+ context *ctx = static_cast<context*>(ptr_context);
*ptr_program = create_program_with_binary(*ctx, num_devices, ptr_devices, num_binaries, binaries);
return 0;
}
- void* program__build(void* ptr_program, char* options, cl_uint num_devices, void** ptr_devices) {
+ void *program__build(void *ptr_program, char *options, cl_uint num_devices, void **ptr_devices) {
// todo: catch error
static_cast<program*>(ptr_program)->build(options, num_devices, ptr_devices);
return 0;
}
- void* program__kind(void* ptr_program, int *kind) {
+ void *program__kind(void *ptr_program, int *kind) {
// todo: catch error
*kind = static_cast<program*>(ptr_program)->kind();
return 0;
}
- void* program__get_info__devices(void* ptr_program, void** ptr_devices, uint32_t* num_devices) {
+ void *program__get_info__devices(void *ptr_program, void **ptr_devices, uint32_t *num_devices) {
typedef std::vector<cl_device_id> vec;
@@ -2092,37 +2088,62 @@ inline event *enqueue_nd_range_kernel(
}
- void* program__get_info__binaries(void* ptr_program, char*** ptr_binaries, uint32_t* num_binaries) {
+ void *program__get_info__binaries(void *ptr_program, char ***ptr_binaries, uint32_t *num_binaries) {
// todo catch error
*ptr_binaries = static_cast<program*>(ptr_program)->get_info__binaries(num_binaries);
return 0;
}
+
long device__hash(void *ptr_device) {
return static_cast<device*>(ptr_device)->hash();
}
- void* _create_kernel(void** ptr_kernel, void* ptr_program, char* name) {
- program* prg = static_cast<program*>(ptr_program);
+ long context__hash(void *ptr_context) {
+ return static_cast<context*>(ptr_context)->hash();
+ }
+
+ long command_queue__hash(void *ptr_command_queue) {
+ return static_cast<command_queue*>(ptr_command_queue)->hash();
+ }
+
+ long event__hash(void *ptr_event) {
+ return static_cast<event*>(ptr_event)->hash();
+ }
+
+ long memory_object_holder__hash(void *ptr_memory_object_holder) {
+ return static_cast<memory_object_holder*>(ptr_memory_object_holder)->hash();
+ }
+
+ long program__hash(void *ptr_program) {
+ return static_cast<program*>(ptr_program)->hash();
+ }
+
+ long kernel__hash(void *ptr_kernel) {
+ return static_cast<kernel*>(ptr_kernel)->hash();
+ }
+
+ void *_create_kernel(void **ptr_kernel, void *ptr_program, char *name) {
+ program *prg = static_cast<program*>(ptr_program);
*ptr_kernel = new kernel(*prg, name);
// todo error handling
return 0;
}
- void* kernel__get_info(void* ptr_kernel, cl_kernel_info param, generic_info* out) {
+ void *kernel__get_info(void *ptr_kernel, cl_kernel_info param, generic_info *out) {
*out = static_cast<kernel*>(ptr_kernel)->get_info(param);
// todo error handling
return 0;
}
- void* kernel__set_arg_mem_buffer(void* ptr_kernel, cl_uint arg_index, void* ptr_buffer) {
- buffer* buf = static_cast<buffer*>(ptr_buffer);
+ void *kernel__set_arg_mem_buffer(void *ptr_kernel, cl_uint arg_index, void *ptr_buffer) {
+ buffer *buf = static_cast<buffer*>(ptr_buffer);
static_cast<kernel*>(ptr_kernel)->set_arg_mem(arg_index, *buf);
// todo error handling
return 0;
}
- void* _enqueue_nd_range_kernel(void **ptr_event, void* ptr_command_queue, void* ptr_kernel, cl_uint work_dim, const size_t* global_work_offset, const size_t* global_work_size, const size_t* local_work_size) {
+ void *_enqueue_nd_range_kernel(void **ptr_event, void *ptr_command_queue, void *ptr_kernel, cl_uint work_dim, const size_t *global_work_offset, const size_t *global_work_size, const size_t *local_work_size) {
*ptr_event = enqueue_nd_range_kernel(*static_cast<command_queue*>(ptr_command_queue),
*static_cast<kernel*>(ptr_kernel),
work_dim,
@@ -2135,7 +2156,7 @@ inline event *enqueue_nd_range_kernel(
}
- void* _enqueue_read_buffer(void **ptr_event, void* ptr_command_queue, void* ptr_memory_object_holder, void* buffer, size_t size, size_t device_offset, int is_blocking) {
+ void *_enqueue_read_buffer(void **ptr_event, void *ptr_command_queue, void *ptr_memory_object_holder, void *buffer, size_t size, size_t device_offset, int is_blocking) {
*ptr_event = enqueue_read_buffer(*static_cast<command_queue*>(ptr_command_queue),
*static_cast<memory_object_holder*>(ptr_memory_object_holder),
buffer, size, device_offset, (bool)is_blocking);
@@ -2143,7 +2164,7 @@ inline event *enqueue_nd_range_kernel(
return 0;
}
- void* memory_object_holder__get_info(void* ptr_memory_object_holder, cl_mem_info param, generic_info* out) {
+ void *memory_object_holder__get_info(void *ptr_memory_object_holder, cl_mem_info param, generic_info *out) {
*out = static_cast<memory_object_holder*>(ptr_memory_object_holder)->get_info(param);
// todo error handling
return 0;
diff --git a/src/c_wrapper/wrap_cl.h b/src/c_wrapper/wrap_cl.h
index 3abd74cf..ce039d14 100644
--- a/src/c_wrapper/wrap_cl.h
+++ b/src/c_wrapper/wrap_cl.h
@@ -63,7 +63,8 @@
extern "C" {
#endif
- #include "wrap_cl_core.h"
+#include "wrap_cl_core.h"
+
#ifdef __cplusplus
}
#endif
diff --git a/src/c_wrapper/wrap_cl_core.h b/src/c_wrapper/wrap_cl_core.h
index b0f8d7fa..1a48511a 100644
--- a/src/c_wrapper/wrap_cl_core.h
+++ b/src/c_wrapper/wrap_cl_core.h
@@ -11,38 +11,41 @@ typedef struct {
union value_t {
cl_uint _cl_uint;
cl_mem_object_type _cl_mem_object_type;
- char* _chars;
+ char *_chars;
} value;
} generic_info;
int get_cl_version(void);
-void* get_platforms(void** ptr_platforms, uint32_t* num_platforms);
-void* platform__get_info(void* ptr_platform, cl_platform_info param_name, generic_info* out);
-void* platform__get_devices(void* ptr_platform, void** ptr_devices, uint32_t* num_devices, cl_device_type devtype);
-void* device__get_info(void* ptr_device, cl_device_info param_name, generic_info* out);
+void *get_platforms(void **ptr_platforms, uint32_t *num_platforms);
+void *platform__get_info(void *ptr_platform, cl_platform_info param_name, generic_info *out);
+void *platform__get_devices(void *ptr_platform, void **ptr_devices, uint32_t *num_devices, cl_device_type devtype);
+long platform__hash(void *ptr_platform);
+void *device__get_info(void *ptr_device, cl_device_info param_name, generic_info *out);
long device__hash(void *ptr_device);
-void* _create_context(void** ptr_ctx, cl_context_properties* properties, cl_uint num_devices, void** ptr_devices);
-void* _create_command_queue(void** ptr_command_queue, void* ptr_context, void* ptr_device, cl_command_queue_properties properties);
-void* _create_buffer(void** ptr_buffer, void* ptr_context, cl_mem_flags flags, size_t size, void* hostbuf);
-void* _create_program_with_source(void **ptr_program, void *ptr_context, char* src);
-void* _create_program_with_binary(void **ptr_program, void *ptr_context, cl_uint num_devices, void** ptr_devices, cl_uint num_binaries, char** binaries);
-void* program__build(void* ptr_program, char* options, cl_uint num_devices, void** ptr_devices);
-void* program__kind(void* ptr_program, int *kind);
-void* program__get_info__devices(void* ptr_program, void** ptr_devices, uint32_t* num_devices);
-void* program__get_info__binaries(void* ptr_program, char*** ptr_binaries, uint32_t* num_binaries);
-void* _create_kernel(void** ptr_kernel, void* ptr_program, char* name);
-void* kernel__get_info(void *ptr_kernel, cl_kernel_info param, generic_info* out);
-void* kernel__set_arg_mem_buffer(void* ptr_kernel, cl_uint arg_index, void* ptr_buffer);
-void* _enqueue_nd_range_kernel(void **ptr_event, void* ptr_command_queue, void* ptr_kernel, cl_uint work_dim, const size_t* global_work_offset, const size_t* global_work_size, const size_t* local_work_size);
-void* _enqueue_read_buffer(void **ptr_event, void* ptr_command_queue, void* ptr_memory_object_holder, void* buffer, size_t size, size_t device_offset, int is_blocking);
-void* memory_object_holder__get_info(void* ptr_memory_object_holder, cl_mem_info param, generic_info* out);
+long context__hash(void *ptr_context);
+long command_queue__hash(void *ptr_command_queue);
+long event__hash(void *ptr_event);
+void *_create_context(void **ptr_ctx, cl_context_properties *properties, cl_uint num_devices, void **ptr_devices);
+void *_create_command_queue(void **ptr_command_queue, void *ptr_context, void *ptr_device, cl_command_queue_properties properties);
+void *_create_buffer(void **ptr_buffer, void *ptr_context, cl_mem_flags flags, size_t size, void *hostbuf);
+void *_create_program_with_source(void **ptr_program, void *ptr_context, char *src);
+void *_create_program_with_binary(void **ptr_program, void *ptr_context, cl_uint num_devices, void **ptr_devices, cl_uint num_binaries, char **binaries);
+void *program__build(void *ptr_program, char *options, cl_uint num_devices, void **ptr_devices);
+void *program__kind(void *ptr_program, int *kind);
+void *program__get_info__devices(void *ptr_program, void **ptr_devices, uint32_t *num_devices);
+void *program__get_info__binaries(void *ptr_program, char ***ptr_binaries, uint32_t *num_binaries);
+long program__hash(void *ptr_program);
+void *_create_kernel(void **ptr_kernel, void *ptr_program, char *name);
+void *kernel__get_info(void *ptr_kernel, cl_kernel_info param, generic_info *out);
+void *kernel__set_arg_mem_buffer(void *ptr_kernel, cl_uint arg_index, void *ptr_buffer);
+long kernel__hash(void *ptr_kernel);
+void *_enqueue_nd_range_kernel(void **ptr_event, void *ptr_command_queue, void *ptr_kernel, cl_uint work_dim, const size_t *global_work_offset, const size_t *global_work_size, const size_t *local_work_size);
+void *_enqueue_read_buffer(void **ptr_event, void *ptr_command_queue, void *ptr_memory_object_holder, void *buffer, size_t size, size_t device_offset, int is_blocking);
+void *memory_object_holder__get_info(void *ptr_memory_object_holder, cl_mem_info param, generic_info *out);
+long memory_object_holder__hash(void *ptr_memory_object_holder);
void populate_constants(void(*add)(const char*, const char*, unsigned int value));
-void freem(void*);
-
-
-
-
-
+void _free(void*);
+void _free2(void**, uint32_t size);
--
GitLab