generic_info
gl_texture::get_gl_texture_info(cl_gl_texture_info param_name) const
{
switch (param_name) {
case CL_GL_TEXTURE_TARGET:
return pyopencl_get_int_info(GLenum, GLTexture, PYOPENCL_CL_CASTABLE_THIS, param_name);
case CL_GL_MIPMAP_LEVEL:
return pyopencl_get_int_info(GLint, GLTexture, PYOPENCL_CL_CASTABLE_THIS, param_name);
default:
throw clerror("MemoryObject.get_gl_texture_info", CL_INVALID_VALUE);
}
}
generic_info
program::get_info(cl_uint param) const
{
switch ((cl_program_info)param) {
case CL_PROGRAM_CONTEXT:
return pyopencl_get_opaque_info(context, Program, this, param);
case CL_PROGRAM_REFERENCE_COUNT:
case CL_PROGRAM_NUM_DEVICES:
return pyopencl_get_int_info(cl_uint, Program, this, param);
case CL_PROGRAM_DEVICES:
return pyopencl_get_opaque_array_info(device, Program, this, param);
case CL_PROGRAM_SOURCE:
return pyopencl_get_str_info(Program, this, param);
case CL_PROGRAM_BINARY_SIZES:
return pyopencl_get_array_info(size_t, Program, this, param);
case CL_PROGRAM_BINARIES: {
auto sizes = pyopencl_get_vec_info(size_t, Program, this,
CL_PROGRAM_BINARY_SIZES);
pyopencl_buf<char*> result_ptrs(sizes.len());
for (size_t i = 0;i < sizes.len();i++) {
result_ptrs[i] = (char*)malloc(sizes[i]);
}
try {
pyopencl_call_guarded(clGetProgramInfo, this, CL_PROGRAM_BINARIES,
sizes.len() * sizeof(char*),
result_ptrs.get(), nullptr);
} catch (...) {
for (size_t i = 0;i < sizes.len();i++) {
free(result_ptrs[i]);
}
}
pyopencl_buf<generic_info> gis(sizes.len());
for (size_t i = 0;i < sizes.len();i++) {
gis[i].value = result_ptrs[i];
gis[i].dontfree = 0;
gis[i].opaque_class = CLASS_NONE;
gis[i].type = _copy_str(std::string("char[") +
tostring(sizes[i]) + "]");
}
return pyopencl_convert_array_info(generic_info, gis);
}
#if PYOPENCL_CL_VERSION >= 0x1020
case CL_PROGRAM_NUM_KERNELS:
return pyopencl_get_int_info(size_t, Program, this, param);
case CL_PROGRAM_KERNEL_NAMES:
return pyopencl_get_str_info(Program, this, param);
#endif
default:
throw clerror("Program.get_info", CL_INVALID_VALUE);
}
}
PYOPENCL_USE_RESULT generic_info
kernel::get_arg_info(cl_uint idx, cl_kernel_arg_info param) const
{
switch (param) {
case CL_KERNEL_ARG_ADDRESS_QUALIFIER:
return pyopencl_get_int_info(cl_kernel_arg_address_qualifier,
KernelArg, this, idx, param);
case CL_KERNEL_ARG_ACCESS_QUALIFIER:
return pyopencl_get_int_info(cl_kernel_arg_access_qualifier,
KernelArg, this, idx, param);
case CL_KERNEL_ARG_TYPE_NAME:
case CL_KERNEL_ARG_NAME:
return pyopencl_get_str_info(KernelArg, this, idx, param);
default:
throw clerror("Kernel.get_arg_info", CL_INVALID_VALUE);
}
}
generic_info
image::get_image_info(cl_image_info param) const
{
switch (param) {
case CL_IMAGE_FORMAT:
return pyopencl_get_int_info(cl_image_format, Image, this, param);
case CL_IMAGE_ELEMENT_SIZE:
case CL_IMAGE_ROW_PITCH:
case CL_IMAGE_SLICE_PITCH:
case CL_IMAGE_WIDTH:
case CL_IMAGE_HEIGHT:
case CL_IMAGE_DEPTH:
#if PYOPENCL_CL_VERSION >= 0x1020
case CL_IMAGE_ARRAY_SIZE:
#endif
return pyopencl_get_int_info(size_t, Image, this, param);
#if PYOPENCL_CL_VERSION >= 0x1020
// TODO:
// case CL_IMAGE_BUFFER:
// {
// cl_mem param_value;
// PYOPENCL_CALL_GUARDED(clGetImageInfo, (this, param, sizeof(param_value), ¶m_value, 0));
// if (param_value == 0)
// {
// // no associated memory object? no problem.
// return py::object();
// }
// return create_mem_object_wrapper(param_value);
// }
case CL_IMAGE_NUM_MIP_LEVELS:
case CL_IMAGE_NUM_SAMPLES:
return pyopencl_get_int_info(cl_uint, Image, this, param);
#endif
default:
throw clerror("Image.get_image_info", CL_INVALID_VALUE);
}
}
generic_info
kernel::get_work_group_info(cl_kernel_work_group_info param,
const device *dev) const
{
switch (param) {
#if PYOPENCL_CL_VERSION >= 0x1010
case CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE:
#endif
case CL_KERNEL_WORK_GROUP_SIZE:
return pyopencl_get_int_info(size_t, KernelWorkGroup, PYOPENCL_CL_CASTABLE_THIS, dev, param);
case CL_KERNEL_COMPILE_WORK_GROUP_SIZE:
return pyopencl_get_array_info(size_t, KernelWorkGroup,
PYOPENCL_CL_CASTABLE_THIS, dev, param);
case CL_KERNEL_LOCAL_MEM_SIZE:
#if PYOPENCL_CL_VERSION >= 0x1010
case CL_KERNEL_PRIVATE_MEM_SIZE:
#endif
return pyopencl_get_int_info(cl_ulong, KernelWorkGroup,
PYOPENCL_CL_CASTABLE_THIS, dev, param);
default:
throw clerror("Kernel.get_work_group_info", CL_INVALID_VALUE);
}
}
generic_info
program::get_build_info(const device *dev, cl_program_build_info param) const
{
switch (param) {
case CL_PROGRAM_BUILD_STATUS:
return pyopencl_get_int_info(cl_build_status, ProgramBuild,
this, dev, param);
case CL_PROGRAM_BUILD_OPTIONS:
case CL_PROGRAM_BUILD_LOG:
return pyopencl_get_str_info(ProgramBuild, this, dev, param);
#if PYOPENCL_CL_VERSION >= 0x1020
case CL_PROGRAM_BINARY_TYPE:
return pyopencl_get_int_info(cl_program_binary_type, ProgramBuild,
this, dev, param);
#endif
#if PYOPENCL_CL_VERSION >= 0x2000
case CL_PROGRAM_BUILD_GLOBAL_VARIABLE_TOTAL_SIZE:
return pyopencl_get_int_info(size_t, ProgramBuild,
this, dev, param);
#endif
default:
throw clerror("Program.get_build_info", CL_INVALID_VALUE);
}
}
generic_info
memory_object::get_info(cl_uint param_name) const
{
switch ((cl_mem_info)param_name) {
case CL_MEM_TYPE:
return pyopencl_get_int_info(cl_mem_object_type, MemObject,
PYOPENCL_CL_CASTABLE_THIS, param_name);
case CL_MEM_FLAGS:
return pyopencl_get_int_info(cl_mem_flags, MemObject,
PYOPENCL_CL_CASTABLE_THIS, param_name);
case CL_MEM_SIZE:
return pyopencl_get_int_info(size_t, MemObject, PYOPENCL_CL_CASTABLE_THIS, param_name);
case CL_MEM_HOST_PTR:
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,
PYOPENCL_CL_CASTABLE_THIS, param_name);
case CL_MEM_CONTEXT:
return pyopencl_get_opaque_info(context, MemObject, PYOPENCL_CL_CASTABLE_THIS, param_name);
#if PYOPENCL_CL_VERSION >= 0x1010
// TODO
// case CL_MEM_ASSOCIATED_MEMOBJECT:
// {
// cl_mem param_value;
// PYOPENCL_CALL_GUARDED(clGetMemObjectInfo, (this, param_name, sizeof(param_value), ¶m_value, 0));
// if (param_value == 0)
// {
// // no associated memory object? no problem.
// return py::object();
// }
// return create_mem_object_wrapper(param_value);
// }
case CL_MEM_OFFSET:
return pyopencl_get_int_info(size_t, MemObject, PYOPENCL_CL_CASTABLE_THIS, param_name);
#endif
#if PYOPENCL_CL_VERSION >= 0x2000
case CL_MEM_USES_SVM_POINTER:
return pyopencl_get_int_info(cl_bool, MemObject, PYOPENCL_CL_CASTABLE_THIS, param_name);
#endif
default:
throw clerror("MemoryObject.get_info", CL_INVALID_VALUE);
}
}
generic_info
kernel::get_info(cl_uint param) const
{
switch ((cl_kernel_info)param) {
case CL_KERNEL_FUNCTION_NAME:
return pyopencl_get_str_info(Kernel, PYOPENCL_CL_CASTABLE_THIS, param);
case CL_KERNEL_NUM_ARGS:
case CL_KERNEL_REFERENCE_COUNT:
return pyopencl_get_int_info(cl_uint, Kernel, PYOPENCL_CL_CASTABLE_THIS, param);
case CL_KERNEL_CONTEXT:
return pyopencl_get_opaque_info(context, Kernel, PYOPENCL_CL_CASTABLE_THIS, param);
case CL_KERNEL_PROGRAM:
return pyopencl_get_opaque_info(program, Kernel, PYOPENCL_CL_CASTABLE_THIS, param);
#if PYOPENCL_CL_VERSION >= 0x1020
case CL_KERNEL_ATTRIBUTES:
return pyopencl_get_str_info(Kernel, PYOPENCL_CL_CASTABLE_THIS, param);
#endif
default:
throw clerror("Kernel.get_info", CL_INVALID_VALUE);
}
}
generic_info
context::get_info(cl_uint param_name) const
{
switch ((cl_context_info)param_name) {
case CL_CONTEXT_REFERENCE_COUNT:
return pyopencl_get_int_info(cl_uint, Context,
PYOPENCL_CL_CASTABLE_THIS, param_name);
case CL_CONTEXT_DEVICES:
return pyopencl_get_opaque_array_info(device, Context,
PYOPENCL_CL_CASTABLE_THIS, param_name);
case CL_CONTEXT_PROPERTIES: {
auto result = pyopencl_get_vec_info(
cl_context_properties, Context, PYOPENCL_CL_CASTABLE_THIS, param_name);
pyopencl_buf<generic_info> py_result(result.len() / 2);
size_t i = 0;
for (;i < py_result.len();i++) {
cl_context_properties key = result[i * 2];
if (key == 0)
break;
cl_context_properties value = result[i * 2 + 1];
generic_info &info = py_result[i];
info.dontfree = 0;
info.opaque_class = CLASS_NONE;
switch (key) {
case CL_CONTEXT_PLATFORM:
info.opaque_class = CLASS_PLATFORM;
info.type = "void *";
info.value = new platform(
reinterpret_cast<cl_platform_id>(value));
break;
#if defined(PYOPENCL_GL_SHARING_VERSION) && (PYOPENCL_GL_SHARING_VERSION >= 1)
#if defined(__APPLE__) && defined(HAVE_GL)
case CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE:
#else
case CL_GL_CONTEXT_KHR:
case CL_EGL_DISPLAY_KHR:
case CL_GLX_DISPLAY_KHR:
case CL_WGL_HDC_KHR:
case CL_CGL_SHAREGROUP_KHR:
#endif
info.type = "intptr_t *";
info.value = (void*)value;
// we do not own this object
info.dontfree = 1;
break;
#endif
default:
throw clerror("Context.get_info", CL_INVALID_VALUE,
"unknown context_property key encountered");
}
}
py_result.resize(i);
return pyopencl_convert_array_info(generic_info, py_result);
}
#if PYOPENCL_CL_VERSION >= 0x1010
case CL_CONTEXT_NUM_DEVICES:
return pyopencl_get_int_info(cl_uint, Context,
PYOPENCL_CL_CASTABLE_THIS, param_name);
#endif
default:
throw clerror("Context.get_info", CL_INVALID_VALUE);
}
}
