From f832f60456f5dedebe08a1fa7b29f0afb2d5a722 Mon Sep 17 00:00:00 2001 From: Andreas Kloeckner Date: Wed, 8 Aug 2018 19:17:45 -0500 Subject: [PATCH] Most of the wrapper builds with pybind11 [ci skip] --- setup.py | 2 +- src/wrap_cl.hpp | 4 +- src/wrap_cl_part_1.cpp | 34 ++++--- src/wrap_cl_part_2.cpp | 221 +++++++++++++++++++++++------------------ src/wrap_constants.cpp | 106 ++++++++++---------- 5 files changed, 200 insertions(+), 167 deletions(-) diff --git a/setup.py b/setup.py index 8e85799d..0fbe8c1d 100644 --- a/setup.py +++ b/setup.py @@ -226,7 +226,7 @@ def main(): "src/wrap_cl.cpp", "src/wrap_cl_part_1.cpp", "src/wrap_cl_part_2.cpp", - #"src/wrap_constants.cpp", + "src/wrap_constants.cpp", "src/wrap_mempool.cpp", "src/bitlog.cpp", ], diff --git a/src/wrap_cl.hpp b/src/wrap_cl.hpp index 7f962fc6..def89e6e 100644 --- a/src/wrap_cl.hpp +++ b/src/wrap_cl.hpp @@ -25,6 +25,8 @@ #else // elsewhere ------------------------------------------------------------------ +#define CL_TARGET_OPENCL_VERSION 220 + #include #include @@ -1519,7 +1521,7 @@ namespace pyopencl inline - event *create_user_event(context &ctx) + user_event *create_user_event(context &ctx) { cl_int status_code; PYOPENCL_PRINT_CALL_TRACE("clCreateUserEvent"); diff --git a/src/wrap_cl_part_1.cpp b/src/wrap_cl_part_1.cpp index cffe95d4..318ba1a9 100644 --- a/src/wrap_cl_part_1.cpp +++ b/src/wrap_cl_part_1.cpp @@ -146,10 +146,12 @@ void pyopencl_expose_part_1(py::module &m) { typedef user_event cls; py::class_(m, "UserEvent") -#if 0 - .def("__init__", make_constructor( - create_user_event, py::default_call_policies(), py::args("context"))) -#endif + .def(py::init( + [](context &ctx) + { + return create_user_event(ctx); + }), + py::arg("context")) .DEF_SIMPLE_METHOD(set_status) ; } @@ -167,10 +169,8 @@ void pyopencl_expose_part_1(py::module &m) py::arg("shape"), py::arg("dtype"), py::arg("order")="C") -#if 0 - .def(py::self == py::self) - .def(py::self != py::self) -#endif + .def("__eq__", [](const cls &self, const cls &other){ return self == other; }) + .def("__ne__", [](const cls &self, const cls &other){ return self != other; }) .def("__hash__", &cls::hash) .def_property_readonly("int_ptr", to_int_ptr, @@ -218,14 +218,16 @@ void pyopencl_expose_part_1(py::module &m) { typedef buffer cls; py::class_(m, "Buffer") -#if 0 - .def("__init__", make_constructor(create_buffer_py, - py::default_call_policies(), - (py::args("context", "flags"), - py::arg("size")=0, - py::arg("hostbuf")=py::object() - ))) -#endif + .def( + py::init( + [](context &ctx, cl_mem_flags flags, size_t size, py::object py_hostbuf) + { return create_buffer_py(ctx, flags, size, py_hostbuf); } + ), + py::arg("context"), + py::arg("flags"), + py::arg("size")=0, + py::arg("hostbuf")=py::object() + ) #if PYOPENCL_CL_VERSION >= 0x1010 .def("get_sub_region", &cls::get_sub_region, py::arg("origin"), diff --git a/src/wrap_cl_part_2.cpp b/src/wrap_cl_part_2.cpp index 4e8f0b8e..e4360882 100644 --- a/src/wrap_cl_part_2.cpp +++ b/src/wrap_cl_part_2.cpp @@ -67,25 +67,43 @@ void pyopencl_expose_part_2(py::module &m) { typedef image cls; py::class_(m, "Image"/* , py::no_init */) -#if 0 - .def("__init__", make_constructor(create_image, - py::default_call_policies(), - py::arg("context"), - py::arg("flags"), - py::arg("format"), - py::arg("shape")=py::object(), - py::arg("pitches")=py::object(), - py::arg("hostbuf")=py::object() - ))) + .def( + py::init( + []( + context const &ctx, + cl_mem_flags flags, + cl_image_format const &fmt, + py::sequence shape, + py::sequence pitches, + py::object buffer) + { + return create_image(ctx, flags, fmt, shape, pitches, buffer); + }), + py::arg("context"), + py::arg("flags"), + py::arg("format"), + py::arg("shape")=py::object(), + py::arg("pitches")=py::object(), + py::arg("hostbuf")=py::object() + ) #if PYOPENCL_CL_VERSION >= 0x1020 - .def("__init__", make_constructor(create_image_from_desc, - py::default_call_policies(), - py::arg("context"), - py::arg("flags"), - py::arg("format"), - py::arg("desc"), - py::arg("hostbuf")=py::object())) -#endif + .def( + py::init( + []( + context const &ctx, + cl_mem_flags flags, + cl_image_format const &fmt, + cl_image_desc &desc, + py::object buffer) + { + return create_image_from_desc(ctx, flags, fmt, desc, buffer); + }), + py::arg("context"), + py::arg("flags"), + py::arg("format"), + py::arg("desc"), + py::arg("hostbuf")=py::object() + ) #endif .DEF_SIMPLE_METHOD(get_image_info) ; @@ -94,9 +112,12 @@ void pyopencl_expose_part_2(py::module &m) { typedef cl_image_format cls; py::class_(m, "ImageFormat") -#if 0 - .def("__init__", py::make_constructor(make_image_format)) -#endif + .def( + py::init( + [](cl_channel_order ord, cl_channel_type tp) + { + return make_image_format(ord, tp); + })) .def_readwrite("channel_order", &cls::image_channel_order) .def_readwrite("channel_data_type", &cls::image_channel_data_type) .def_property_readonly("channel_count", &get_image_format_channel_count) @@ -171,14 +192,14 @@ void pyopencl_expose_part_2(py::module &m) // }}} -#if 0 // {{{ memory_map { typedef memory_map cls; - py::class_("MemoryMap", py::no_init) + py::class_(m, "MemoryMap") .def("release", &cls::release, - (py::arg("queue")=0, py::arg("wait_for")=py::object()), - py::return_value_policy()) + py::arg("queue")=0, + py::arg("wait_for")=py::object() + ) ; } @@ -192,7 +213,7 @@ void pyopencl_expose_part_2(py::module &m) py::arg("order")="C", py::arg("strides")=py::object(), py::arg("wait_for")=py::object(), - py::arg("is_blocking")=true)); + py::arg("is_blocking")=true); m.def("enqueue_map_image", enqueue_map_image, py::arg("queue"), py::arg("img"), @@ -211,8 +232,8 @@ void pyopencl_expose_part_2(py::module &m) // {{{ sampler { typedef sampler cls; - py::class_("Sampler", - py::init()) + py::class_(m, "Sampler") + .def(py::init()) .DEF_SIMPLE_METHOD(get_info) .def(py::self == py::self) .def(py::self != py::self) @@ -226,50 +247,56 @@ void pyopencl_expose_part_2(py::module &m) // {{{ program { typedef program cls; - py::enum_("program_kind") + py::enum_(m, "program_kind") .value("UNKNOWN", cls::KND_UNKNOWN) .value("SOURCE", cls::KND_SOURCE) .value("BINARY", cls::KND_BINARY) ; - py::class_("_Program", py::no_init) - .def("__init__", make_constructor( - create_program_with_source, - py::default_call_policies(), - py::arg("context"), - py::arg("src"))) - .def("__init__", make_constructor( - create_program_with_binary, - py::default_call_policies(), - py::arg("context"), - py::arg("devices"), - py::arg("binaries")))) + py::class_(m, "_Program") + .def( + py::init( + [](context &ctx, std::string const &src) + { + return create_program_with_source(ctx, src); + }), + py::arg("context"), + py::arg("src")) + .def( + py::init( + [](context &ctx, py::sequence devices, py::sequence binaries) + { + return create_program_with_binary(ctx, devices, binaries); + }), + py::arg("context"), + py::arg("devices"), + py::arg("binaries")) #if (PYOPENCL_CL_VERSION >= 0x1020) && \ ((PYOPENCL_CL_VERSION >= 0x1030) && defined(__APPLE__)) - .def("create_with_built_in_kernels", + .def_static("create_with_built_in_kernels", create_program_with_built_in_kernels, py::arg("context"), py::arg("devices"), py::arg("kernel_names"), py::return_value_policy()) - .staticmethod("create_with_built_in_kernels") #endif .DEF_SIMPLE_METHOD(kind) .DEF_SIMPLE_METHOD(get_info) .DEF_SIMPLE_METHOD(get_build_info) .def("_build", &cls::build, - (py::arg("options")="", py::arg("devices")=py::object())) + py::arg("options")="", + py::arg("devices")=py::object()) #if PYOPENCL_CL_VERSION >= 0x1020 .def("compile", &cls::compile, - (py::arg("options")="", py::arg("devices")=py::object(), - py::arg("headers")=py::list())) - .def("link", &link_program, - (py::arg("context"), - py::arg("programs"), - py::arg("options")="", - py::arg("devices")=py::object()), - py::return_value_policy()) - .staticmethod("link") + py::arg("options")="", + py::arg("devices")=py::object(), + py::arg("headers")=py::list()) + .def_static("link", &link_program, + py::arg("context"), + py::arg("programs"), + py::arg("options")="", + py::arg("devices")=py::object() + ) #endif .def(py::self == py::self) .def(py::self != py::self) @@ -289,8 +316,8 @@ void pyopencl_expose_part_2(py::module &m) { typedef kernel cls; - py::class_("Kernel", - py::init()) + py::class_(m, "Kernel") + .def(py::init()) .DEF_SIMPLE_METHOD(get_info) .DEF_SIMPLE_METHOD(get_work_group_info) .DEF_SIMPLE_METHOD(set_arg) @@ -306,9 +333,11 @@ void pyopencl_expose_part_2(py::module &m) { typedef local_memory cls; - py::class_("LocalMemory", - py::init(py::arg("size"))) - .def_property("size", &cls::size) + py::class_(m, "LocalMemory") + .def( + py::init(), + py::arg("size")) + .def_property_readonly("size", &cls::size) ; } @@ -321,14 +350,12 @@ void pyopencl_expose_part_2(py::module &m) py::arg("global_work_offset")=py::object(), py::arg("wait_for")=py::object(), py::arg("g_times_l")=false - ), - py::return_value_policy()); + ); m.def("enqueue_task", enqueue_task, py::arg("queue"), py::arg("kernel"), py::arg("wait_for")=py::object() - ), - py::return_value_policy()); + ); // TODO: clEnqueueNativeKernel // }}} @@ -344,42 +371,52 @@ void pyopencl_expose_part_2(py::module &m) { typedef gl_buffer cls; - py::class_, boost::noncopyable>( - "GLBuffer", py::no_init) - .def("__init__", make_constructor(create_from_gl_buffer, - py::default_call_policies(), - py::arg("context"), - py::arg("flags"), - py::arg("bufobj"))) + py::class_(m, "GLBuffer") + .def( + py::init( + [](context &ctx, cl_mem_flags flags, GLuint bufobj) + { + return create_from_gl_buffer(ctx, flags, bufobj); + }), + py::arg("context"), + py::arg("flags"), + py::arg("bufobj")) .def("get_gl_object_info", get_gl_object_info) ; } { typedef gl_renderbuffer cls; - py::class_, boost::noncopyable>( - "GLRenderBuffer", py::no_init) - .def("__init__", make_constructor(create_from_gl_renderbuffer, - py::default_call_policies(), - py::arg("context"), - py::arg("flags"), - py::arg("bufobj"))) + py::class_(m, "GLRenderBuffer") + .def( + py::init( + [](context &ctx, cl_mem_flags flags, GLuint bufobj) + { + return create_from_gl_renderbuffer(ctx, flags, bufobj); + }), + py::arg("context"), + py::arg("flags"), + py::arg("bufobj")) .def("get_gl_object_info", get_gl_object_info) ; } { typedef gl_texture cls; - py::class_, boost::noncopyable>( - "GLTexture", py::no_init) - .def("__init__", make_constructor(create_from_gl_texture, - py::default_call_policies(), - py::arg("context"), - py::arg("flags"), - py::arg("texture_target"), - py::arg("miplevel"), - py::arg("texture"), - py::arg("dims"))) + py::class_(m, "GLTexture") + .def( + py::init( + [](context &ctx, cl_mem_flags flags, GLenum texture_target, + GLint miplevel, GLuint texture, unsigned dims) + { + return create_from_gl_texture(ctx, flags, texture_target, miplevel, texture, dims); + }), + py::arg("context"), + py::arg("flags"), + py::arg("texture_target"), + py::arg("miplevel"), + py::arg("texture"), + py::arg("dims")) .def("get_gl_object_info", get_gl_object_info) .DEF_SIMPLE_METHOD(get_gl_texture_info) ; @@ -389,28 +426,24 @@ void pyopencl_expose_part_2(py::module &m) py::arg("queue"), py::arg("mem_objects"), py::arg("wait_for")=py::object() - ), - py::return_value_policy()); + ); m.def("enqueue_release_gl_objects", enqueue_release_gl_objects, py::arg("queue"), py::arg("mem_objects"), py::arg("wait_for")=py::object() - ), - py::return_value_policy()); + ); #if defined(cl_khr_gl_sharing) && (cl_khr_gl_sharing >= 1) m.def("get_gl_context_info_khr", get_gl_context_info_khr, py::arg("properties"), py::arg("param_name"), - py::arg("platform")=py::object())); + py::arg("platform")=py::object() + ); #endif #endif // }}} -#endif } - - // vim: foldmethod=marker diff --git a/src/wrap_constants.cpp b/src/wrap_constants.cpp index 64511d01..5b195687 100644 --- a/src/wrap_constants.cpp +++ b/src/wrap_constants.cpp @@ -1,16 +1,13 @@ #include "wrap_cl.hpp" - - using namespace pyopencl; - - namespace { - py::handle<> +#if 0 + py::handle CLError, CLMemoryError, CLLogicError, @@ -30,8 +27,7 @@ namespace else PyErr_SetObject(CLError.get(), py::object(err).ptr()); } - - +#endif // {{{ 'fake' constant scopes @@ -88,10 +84,9 @@ namespace } - - -void pyopencl_expose_constants() +void pyopencl_expose_constants(py::module &m) { +#if 0 // {{{ exceptions #define DECLARE_EXC(NAME, BASE) \ CL##NAME = py::handle<>(PyErr_NewException("pyopencl." #NAME, BASE, NULL)); \ @@ -106,6 +101,7 @@ void pyopencl_expose_constants() py::register_exception_translator(translate_cl_error); } // }}} +#endif // {{{ constants #define ADD_ATTR(PREFIX, NAME) \ @@ -115,7 +111,7 @@ void pyopencl_expose_constants() { typedef error cls; - py::class_ ("_error", py::no_init) + py::class_ (m, "_error") .DEF_SIMPLE_METHOD(routine) .DEF_SIMPLE_METHOD(code) .DEF_SIMPLE_METHOD(what) @@ -123,7 +119,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("status_code", py::no_init); + py::class_ cls(m, "status_code"); ADD_ATTR(, SUCCESS); ADD_ATTR(, DEVICE_NOT_FOUND); @@ -209,7 +205,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("platform_info", py::no_init); + py::class_ cls(m, "platform_info"); ADD_ATTR(PLATFORM_, PROFILE); ADD_ATTR(PLATFORM_, VERSION); ADD_ATTR(PLATFORM_, NAME); @@ -220,7 +216,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("device_type", py::no_init); + py::class_ cls(m, "device_type"); ADD_ATTR(DEVICE_TYPE_, DEFAULT); ADD_ATTR(DEVICE_TYPE_, CPU); ADD_ATTR(DEVICE_TYPE_, GPU); @@ -232,7 +228,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("device_info", py::no_init); + py::class_ cls(m, "device_info"); ADD_ATTR(DEVICE_, TYPE); ADD_ATTR(DEVICE_, VENDOR_ID); ADD_ATTR(DEVICE_, MAX_COMPUTE_UNITS); @@ -384,7 +380,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("device_fp_config", py::no_init); + py::class_ cls(m, "device_fp_config"); ADD_ATTR(FP_, DENORM); ADD_ATTR(FP_, INF_NAN); ADD_ATTR(FP_, ROUND_TO_NEAREST); @@ -400,20 +396,20 @@ void pyopencl_expose_constants() } { - py::class_ cls("device_mem_cache_type", py::no_init); + py::class_ cls(m, "device_mem_cache_type"); ADD_ATTR( , NONE); ADD_ATTR( , READ_ONLY_CACHE); ADD_ATTR( , READ_WRITE_CACHE); } { - py::class_ cls("device_local_mem_type", py::no_init); + py::class_ cls(m, "device_local_mem_type"); ADD_ATTR( , LOCAL); ADD_ATTR( , GLOBAL); } { - py::class_ cls("device_exec_capabilities", py::no_init); + py::class_ cls(m, "device_exec_capabilities"); ADD_ATTR(EXEC_, KERNEL); ADD_ATTR(EXEC_, NATIVE_KERNEL); #ifdef CL_EXEC_IMMEDIATE_EXECUTION_INTEL @@ -422,7 +418,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("command_queue_properties", py::no_init); + py::class_ cls(m, "command_queue_properties"); ADD_ATTR(QUEUE_, OUT_OF_ORDER_EXEC_MODE_ENABLE); ADD_ATTR(QUEUE_, PROFILING_ENABLE); #ifdef CL_QUEUE_IMMEDIATE_EXECUTION_ENABLE_INTEL @@ -431,7 +427,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("context_info", py::no_init); + py::class_ cls(m, "context_info"); ADD_ATTR(CONTEXT_, REFERENCE_COUNT); ADD_ATTR(CONTEXT_, DEVICES); ADD_ATTR(CONTEXT_, PROPERTIES); @@ -444,7 +440,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("gl_context_info", py::no_init); + py::class_ cls(m, "gl_context_info"); #if defined(cl_khr_gl_sharing) && (cl_khr_gl_sharing >= 1) ADD_ATTR(, CURRENT_DEVICE_FOR_GL_CONTEXT_KHR); ADD_ATTR(, DEVICES_FOR_GL_CONTEXT_KHR); @@ -452,7 +448,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("context_properties", py::no_init); + py::class_ cls(m, "context_properties"); ADD_ATTR(CONTEXT_, PLATFORM); #if defined(cl_khr_gl_sharing) && (cl_khr_gl_sharing >= 1) ADD_ATTR( ,GL_CONTEXT_KHR); @@ -471,7 +467,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("command_queue_info", py::no_init); + py::class_ cls(m, "command_queue_info"); ADD_ATTR(QUEUE_, CONTEXT); ADD_ATTR(QUEUE_, DEVICE); ADD_ATTR(QUEUE_, REFERENCE_COUNT); @@ -479,7 +475,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("mem_flags", py::no_init); + py::class_ cls(m, "mem_flags"); ADD_ATTR(MEM_, READ_WRITE); ADD_ATTR(MEM_, WRITE_ONLY); ADD_ATTR(MEM_, READ_ONLY); @@ -497,7 +493,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("channel_order", py::no_init); + py::class_ cls(m, "channel_order"); ADD_ATTR( , R); ADD_ATTR( , A); ADD_ATTR( , RG); @@ -515,7 +511,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("channel_type", py::no_init); + py::class_ cls(m, "channel_type"); ADD_ATTR( , SNORM_INT8); ADD_ATTR( , SNORM_INT16); ADD_ATTR( , UNORM_INT8); @@ -534,7 +530,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("mem_object_type", py::no_init); + py::class_ cls(m, "mem_object_type"); ADD_ATTR(MEM_OBJECT_, BUFFER); ADD_ATTR(MEM_OBJECT_, IMAGE2D); ADD_ATTR(MEM_OBJECT_, IMAGE3D); @@ -547,7 +543,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("mem_info", py::no_init); + py::class_ cls(m, "mem_info"); ADD_ATTR(MEM_, TYPE); ADD_ATTR(MEM_, FLAGS); ADD_ATTR(MEM_, SIZE); @@ -562,7 +558,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("image_info", py::no_init); + py::class_ cls(m, "image_info"); ADD_ATTR(IMAGE_, FORMAT); ADD_ATTR(IMAGE_, ELEMENT_SIZE); ADD_ATTR(IMAGE_, ROW_PITCH); @@ -579,7 +575,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("addressing_mode", py::no_init); + py::class_ cls(m, "addressing_mode"); ADD_ATTR(ADDRESS_, NONE); ADD_ATTR(ADDRESS_, CLAMP_TO_EDGE); ADD_ATTR(ADDRESS_, CLAMP); @@ -590,13 +586,13 @@ void pyopencl_expose_constants() } { - py::class_ cls("filter_mode", py::no_init); + py::class_ cls(m, "filter_mode"); ADD_ATTR(FILTER_, NEAREST); ADD_ATTR(FILTER_, LINEAR); } { - py::class_ cls("sampler_info", py::no_init); + py::class_ cls(m, "sampler_info"); ADD_ATTR(SAMPLER_, REFERENCE_COUNT); ADD_ATTR(SAMPLER_, CONTEXT); ADD_ATTR(SAMPLER_, NORMALIZED_COORDS); @@ -605,7 +601,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("map_flags", py::no_init); + py::class_ cls(m, "map_flags"); ADD_ATTR(MAP_, READ); ADD_ATTR(MAP_, WRITE); #if PYOPENCL_CL_VERSION >= 0x1020 @@ -614,7 +610,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("program_info", py::no_init); + py::class_ cls(m, "program_info"); ADD_ATTR(PROGRAM_, REFERENCE_COUNT); ADD_ATTR(PROGRAM_, CONTEXT); ADD_ATTR(PROGRAM_, NUM_DEVICES); @@ -629,7 +625,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("program_build_info", py::no_init); + py::class_ cls(m, "program_build_info"); ADD_ATTR(PROGRAM_BUILD_, STATUS); ADD_ATTR(PROGRAM_BUILD_, OPTIONS); ADD_ATTR(PROGRAM_BUILD_, LOG); @@ -639,7 +635,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("program_binary_type", py::no_init); + py::class_ cls(m, "program_binary_type"); #if PYOPENCL_CL_VERSION >= 0x1020 ADD_ATTR(PROGRAM_BINARY_TYPE_, NONE); ADD_ATTR(PROGRAM_BINARY_TYPE_, COMPILED_OBJECT); @@ -649,7 +645,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("kernel_info", py::no_init); + py::class_ cls(m, "kernel_info"); ADD_ATTR(KERNEL_, FUNCTION_NAME); ADD_ATTR(KERNEL_, NUM_ARGS); ADD_ATTR(KERNEL_, REFERENCE_COUNT); @@ -661,7 +657,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("kernel_arg_info", py::no_init); + py::class_ cls(m, "kernel_arg_info"); #if PYOPENCL_CL_VERSION >= 0x1020 ADD_ATTR(KERNEL_ARG_, ADDRESS_QUALIFIER); ADD_ATTR(KERNEL_ARG_, ACCESS_QUALIFIER); @@ -672,7 +668,7 @@ void pyopencl_expose_constants() { py::class_ cls( - "kernel_arg_address_qualifier", py::no_init); + m, "kernel_arg_address_qualifier"); #if PYOPENCL_CL_VERSION >= 0x1020 ADD_ATTR(KERNEL_ARG_ADDRESS_, GLOBAL); ADD_ATTR(KERNEL_ARG_ADDRESS_, LOCAL); @@ -683,7 +679,7 @@ void pyopencl_expose_constants() { py::class_ cls( - "kernel_arg_access_qualifier", py::no_init); + m, "kernel_arg_access_qualifier"); #if PYOPENCL_CL_VERSION >= 0x1020 ADD_ATTR(KERNEL_ARG_ACCESS_, READ_ONLY); ADD_ATTR(KERNEL_ARG_ACCESS_, WRITE_ONLY); @@ -693,7 +689,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("kernel_work_group_info", py::no_init); + py::class_ cls(m, "kernel_work_group_info"); ADD_ATTR(KERNEL_, WORK_GROUP_SIZE); ADD_ATTR(KERNEL_, COMPILE_WORK_GROUP_SIZE); ADD_ATTR(KERNEL_, LOCAL_MEM_SIZE); @@ -707,7 +703,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("event_info", py::no_init); + py::class_ cls(m, "event_info"); ADD_ATTR(EVENT_, COMMAND_QUEUE); ADD_ATTR(EVENT_, COMMAND_TYPE); ADD_ATTR(EVENT_, REFERENCE_COUNT); @@ -718,7 +714,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("command_type", py::no_init); + py::class_ cls(m, "command_type"); ADD_ATTR(COMMAND_, NDRANGE_KERNEL); ADD_ATTR(COMMAND_, TASK); ADD_ATTR(COMMAND_, NATIVE_KERNEL); @@ -754,7 +750,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("command_execution_status", py::no_init); + py::class_ cls(m, "command_execution_status"); ADD_ATTR(, COMPLETE); ADD_ATTR(, RUNNING); ADD_ATTR(, SUBMITTED); @@ -762,7 +758,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("profiling_info", py::no_init); + py::class_ cls(m, "profiling_info"); ADD_ATTR(PROFILING_COMMAND_, QUEUED); ADD_ATTR(PROFILING_COMMAND_, SUBMIT); ADD_ATTR(PROFILING_COMMAND_, START); @@ -772,7 +768,7 @@ void pyopencl_expose_constants() /* not needed--filled in automatically by implementation. #if PYOPENCL_CL_VERSION >= 0x1010 { - py::class_ cls("buffer_create_type", py::no_init); + py::class_ cls(m, "buffer_create_type"); ADD_ATTR(BUFFER_CREATE_TYPE_, REGION); } #endif @@ -780,7 +776,7 @@ void pyopencl_expose_constants() { py::class_ cls( - "mem_migration_flags", py::no_init); + m, "mem_migration_flags"); #if PYOPENCL_CL_VERSION >= 0x1020 ADD_ATTR(MIGRATE_MEM_OBJECT_, HOST); ADD_ATTR(MIGRATE_MEM_OBJECT_, CONTENT_UNDEFINED); @@ -789,7 +785,7 @@ void pyopencl_expose_constants() { py::class_ cls( - "device_partition_property_ext", py::no_init); + m, "device_partition_property_ext"); #if defined(cl_ext_device_fission) && defined(PYOPENCL_USE_DEVICE_FISSION) ADD_ATTR_SUFFIX(DEVICE_PARTITION_, EQUALLY, _EXT); ADD_ATTR_SUFFIX(DEVICE_PARTITION_, BY_COUNTS, _EXT); @@ -802,7 +798,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("affinity_domain_ext", py::no_init); + py::class_ cls(m, "affinity_domain_ext"); #if defined(cl_ext_device_fission) && defined(PYOPENCL_USE_DEVICE_FISSION) ADD_ATTR_SUFFIX(AFFINITY_DOMAIN_, L1_CACHE, _EXT); ADD_ATTR_SUFFIX(AFFINITY_DOMAIN_, L2_CACHE, _EXT); @@ -815,7 +811,7 @@ void pyopencl_expose_constants() { py::class_ cls( - "device_partition_property", py::no_init); + m, "device_partition_property"); #if PYOPENCL_CL_VERSION >= 0x1020 ADD_ATTR(DEVICE_PARTITION_, EQUALLY); ADD_ATTR(DEVICE_PARTITION_, BY_COUNTS); @@ -825,7 +821,7 @@ void pyopencl_expose_constants() } { - py::class_ cls("device_affinity_domain", py::no_init); + py::class_ cls(m, "device_affinity_domain"); #if PYOPENCL_CL_VERSION >= 0x1020 ADD_ATTR(DEVICE_AFFINITY_DOMAIN_, NUMA); ADD_ATTR(DEVICE_AFFINITY_DOMAIN_, L4_CACHE); @@ -838,7 +834,7 @@ void pyopencl_expose_constants() #ifdef HAVE_GL { - py::class_ cls("gl_object_type", py::no_init); + py::class_ cls(m, "gl_object_type"); ADD_ATTR(GL_OBJECT_, BUFFER); ADD_ATTR(GL_OBJECT_, TEXTURE2D); ADD_ATTR(GL_OBJECT_, TEXTURE3D); @@ -846,14 +842,14 @@ void pyopencl_expose_constants() } { - py::class_ cls("gl_texture_info", py::no_init); + py::class_ cls(m, "gl_texture_info"); ADD_ATTR(GL_, TEXTURE_TARGET); ADD_ATTR(GL_, MIPMAP_LEVEL); } #endif { - py::class_ cls("migrate_mem_object_flags_ext", py::no_init); + py::class_ cls(m, "migrate_mem_object_flags_ext"); #ifdef cl_ext_migrate_memobject ADD_ATTR_SUFFIX(MIGRATE_MEM_OBJECT_, HOST, _EXT); #endif -- GitLab