error*
enqueue_migrate_mem_object_ext(clobj_t *evt, clobj_t _queue,
const clobj_t *_mem_obj, uint32_t num_mem_obj,
cl_mem_migration_flags_ext flags,
const clobj_t *_wait_for, uint32_t num_wait_for)
{
const auto wait_for = buf_from_class<event>(_wait_for, num_wait_for);
const auto mem_obj = buf_from_class<memory_object>(_mem_obj, num_mem_obj);
auto queue = static_cast<command_queue*>(_queue);
return c_handle_error([&] {
#if PYOPENCL_CL_VERSION >= 0x1020
// {{{ get platform
cl_device_id dev;
pyopencl_call_guarded(clGetCommandQueueInfo, queue, CL_QUEUE_DEVICE,
size_arg(dev), nullptr);
cl_platform_id plat;
pyopencl_call_guarded(clGetDeviceInfo, dev, CL_DEVICE_PLATFORM,
size_arg(plat), nullptr);
// }}}
#endif
auto clEnqueueMigrateMemObjectEXT =
pyopencl_get_ext_fun(plat, clEnqueueMigrateMemObjectEXT);
retry_mem_error([&] {
pyopencl_call_guarded(clEnqueueMigrateMemObjectsEXT, queue,
mem_obj, flags, wait_for,
event_out(evt));
});
});
}
error*
memory_object__get_host_array(clobj_t _obj, void **hostptr, size_t *size)
{
auto obj = static_cast<memory_object*>(_obj);
return c_handle_error([&] {
cl_mem_flags flags;
pyopencl_call_guarded(clGetMemObjectInfo, obj, CL_MEM_FLAGS,
size_arg(flags), nullptr);
if (!(flags & CL_MEM_USE_HOST_PTR))
throw clerror("MemoryObject.get_host_array", CL_INVALID_VALUE,
"Only MemoryObject with USE_HOST_PTR "
"is supported.");
pyopencl_call_guarded(clGetMemObjectInfo, obj, CL_MEM_HOST_PTR,
size_arg(*hostptr), nullptr);
pyopencl_call_guarded(clGetMemObjectInfo, obj, CL_MEM_SIZE,
size_arg(*size), nullptr);
});
}
error*
kernel__set_arg_null(clobj_t _knl, cl_uint arg_index)
{
auto knl = static_cast<kernel*>(_knl);
return c_handle_error([&] {
const cl_mem m = 0;
pyopencl_call_guarded(clSetKernelArg, knl, arg_index, size_arg(m));
});
}
error*
kernel__set_arg_buf(clobj_t _knl, cl_uint arg_index,
const void *buffer, size_t size)
{
auto knl = static_cast<kernel*>(_knl);
return c_handle_error([&] {
pyopencl_call_guarded(clSetKernelArg, knl, arg_index,
size_arg(buffer, size));
});
}
error*
kernel__set_arg_sampler(clobj_t _knl, cl_uint arg_index, clobj_t _samp)
{
auto knl = static_cast<kernel*>(_knl);
auto samp = static_cast<sampler*>(_samp);
return c_handle_error([&] {
pyopencl_call_guarded(clSetKernelArg, knl, arg_index,
size_arg(samp->data()));
});
}
error*
kernel__set_arg_mem(clobj_t _knl, cl_uint arg_index, clobj_t _mem)
{
auto knl = static_cast<kernel*>(_knl);
auto mem = static_cast<memory_object*>(_mem);
return c_handle_error([&] {
pyopencl_call_guarded(clSetKernelArg, knl, arg_index,
size_arg(mem->data()));
});
}
void
context::get_version(cl_context ctx, int *major, int *minor)
{
cl_device_id s_buff[16];
size_t size;
pyopencl_buf<cl_device_id> d_buff(0);
cl_device_id *devs = s_buff;
pyopencl_call_guarded(clGetContextInfo, ctx, CL_CONTEXT_DEVICES,
0, nullptr, buf_arg(size));
if (PYOPENCL_UNLIKELY(!size)) {
throw clerror("Context.get_version", CL_INVALID_VALUE,
"Cannot get devices from context.");
}
if (PYOPENCL_UNLIKELY(size > sizeof(s_buff))) {
d_buff.resize(size / sizeof(cl_device_id));
devs = d_buff.get();
}
pyopencl_call_guarded(clGetContextInfo, ctx, CL_CONTEXT_DEVICES,
size_arg(devs, size), buf_arg(size));
device::get_version(devs[0], major, minor);
}
void
platform::get_version(cl_platform_id plat, int *major, int *minor)
{
char s_buff[128];
size_t size;
pyopencl_buf<char> d_buff(0);
char *name = s_buff;
pyopencl_call_guarded(clGetPlatformInfo, plat, CL_PLATFORM_VERSION,
0, nullptr, buf_arg(size));
if (PYOPENCL_UNLIKELY(size > sizeof(s_buff))) {
d_buff.resize(size);
name = d_buff.get();
}
pyopencl_call_guarded(clGetPlatformInfo, plat, CL_PLATFORM_VERSION,
size_arg(name, size), buf_arg(size));
std::cmatch ver_match;
if (!std::regex_match(name, ver_match, ver_regex)) {
throw clerror("Platform.get_version", CL_INVALID_VALUE,
"platform returned non-conformant "
"platform version string");
}
*major = atoi(name + ver_match.position(1));
*minor = atoi(name + ver_match.position(2));
}
