From 61eb4cfd11ff17ab5fbc2ed1897be3920cb7d042 Mon Sep 17 00:00:00 2001 From: Andreas Kloeckner Date: Fri, 2 Jul 2010 22:42:14 -0400 Subject: [PATCH] Split the CL wrapper, move to a new bpl-subset, remove no-config warning. --- aksetup_helper.py | 11 +- bpl-subset | 2 +- setup.py | 6 +- src/wrapper/wrap_cl.cpp | 928 +-------------------------------- src/wrapper/wrap_cl.hpp | 3 + src/wrapper/wrap_cl_part_1.cpp | 222 ++++++++ src/wrapper/wrap_cl_part_2.cpp | 242 +++++++++ src/wrapper/wrap_constants.cpp | 510 ++++++++++++++++++ 8 files changed, 992 insertions(+), 932 deletions(-) create mode 100644 src/wrapper/wrap_cl_part_1.cpp create mode 100644 src/wrapper/wrap_cl_part_2.cpp create mode 100644 src/wrapper/wrap_constants.cpp diff --git a/aksetup_helper.py b/aksetup_helper.py index feefb81e..345cc94d 100644 --- a/aksetup_helper.py +++ b/aksetup_helper.py @@ -103,12 +103,13 @@ def humanize(sym_str): # siteconf handling ----------------------------------------------------------- -def get_config(schema=None): +def get_config(schema=None, warn_about_no_config=True): if schema is None: from setup import get_config_schema schema = get_config_schema() - if not schema.have_config() and not schema.have_global_config(): + if (not schema.have_config() and not schema.have_global_config() + and warn_about_no_config): print "*************************************************************" print "*** I have detected that you have not run configure.py." print "*************************************************************" @@ -497,20 +498,14 @@ def set_up_shipped_boost_if_requested(conf): + glob("bpl-subset/bpl_subset/libs/*/*/*.cpp") + glob("bpl-subset/bpl_subset/libs/*/*.cpp")) - print len(source_files) source_files = [f for f in source_files if not f.startswith("bpl-subset/bpl_subset/libs/thread/src")] - print len(source_files) import sys if sys.platform == "nt": - print glob( - "bpl-subset/bpl_subset/libs/thread/src/win32/*.cpp") source_files += glob( "bpl-subset/bpl_subset/libs/thread/src/win32/*.cpp") else: - print glob( - "bpl-subset/bpl_subset/libs/thread/src/pthread/*.cpp") source_files += glob( "bpl-subset/bpl_subset/libs/thread/src/pthread/*.cpp") diff --git a/bpl-subset b/bpl-subset index eb21ae67..19b13cae 160000 --- a/bpl-subset +++ b/bpl-subset @@ -1 +1 @@ -Subproject commit eb21ae675a7e5d9b7ca19303ce1bd2bf95444118 +Subproject commit 19b13cae1f63e75dbf18b90020e4877639ab9f0e diff --git a/setup.py b/setup.py index 1cbec792..9d88540d 100644 --- a/setup.py +++ b/setup.py @@ -46,7 +46,8 @@ def main(): NumpyExtension, set_up_shipped_boost_if_requested) hack_distutils() - conf = get_config(get_config_schema()) + conf = get_config(get_config_schema(), + warn_about_no_config=False) EXTRA_OBJECTS, EXTRA_DEFINES = set_up_shipped_boost_if_requested(conf) LIBRARY_DIRS = conf["BOOST_LIB_DIR"] @@ -139,6 +140,9 @@ def main(): NumpyExtension("_cl", [ "src/wrapper/wrap_cl.cpp", + "src/wrapper/wrap_cl_part_1.cpp", + "src/wrapper/wrap_cl_part_2.cpp", + "src/wrapper/wrap_constants.cpp", ]+EXTRA_OBJECTS, include_dirs=INCLUDE_DIRS + EXTRA_INCLUDE_DIRS, library_dirs=LIBRARY_DIRS + conf["CL_LIB_DIR"], diff --git a/src/wrapper/wrap_cl.cpp b/src/wrapper/wrap_cl.cpp index 7604e3c3..903cc666 100644 --- a/src/wrapper/wrap_cl.cpp +++ b/src/wrapper/wrap_cl.cpp @@ -8,931 +8,15 @@ using namespace pyopencl; -namespace -{ - py::handle<> - CLError, - CLMemoryError, - CLLogicError, - CLRuntimeError; - - - - - void translate_cl_error(const error &err) - { - if (err.code() == CL_MEM_OBJECT_ALLOCATION_FAILURE) - PyErr_SetString(CLMemoryError.get(), err.what()); - else if (err.code() <= CL_INVALID_VALUE) - PyErr_SetString(CLLogicError.get(), err.what()); - else if (err.code() > CL_INVALID_VALUE && err.code() < CL_SUCCESS) - PyErr_SetString(CLRuntimeError.get(), err.what()); - else - PyErr_SetString(CLError.get(), err.what()); - } - - - - - // {{{ 'fake' constant scopes - class platform_info { }; - class device_type { }; - class device_info { }; - class device_fp_config { }; - class device_mem_cache_type { }; - class device_local_mem_type { }; - class device_exec_capabilities { }; - class command_queue_properties { }; - class context_info { }; - class gl_context_info { }; - class context_properties { }; - class command_queue_info { }; - class mem_flags { }; - class channel_order { }; - class channel_type { }; - class mem_object_type { }; - class mem_info { }; - class image_info { }; - class addressing_mode { }; - class filter_mode { }; - class sampler_info { }; - class map_flags { }; - class program_info { }; - class program_build_info { }; - class build_status { }; - class kernel_info { }; - class kernel_work_group_info { }; - class event_info { }; - class command_type { }; - class command_execution_status { }; - class profiling_info { }; - class buffer_create_type { }; - - class gl_object_type { }; - class gl_texture_info { }; - // }}} -} - - - +extern void pyopencl_expose_constants(); +extern void pyopencl_expose_part_1(); +extern void pyopencl_expose_part_2(); BOOST_PYTHON_MODULE(_cl) { - // {{{ exceptions -#define DECLARE_EXC(NAME, BASE) \ - CL##NAME = py::handle<>(PyErr_NewException("pyopencl." #NAME, BASE, NULL)); \ - py::scope().attr(#NAME) = CL##NAME; - - { - DECLARE_EXC(Error, NULL); - py::tuple memerr_bases = py::make_tuple( - CLError, - py::handle<>(py::borrowed(PyExc_MemoryError))); - DECLARE_EXC(MemoryError, memerr_bases.ptr()); - DECLARE_EXC(LogicError, CLLogicError.get()); - DECLARE_EXC(RuntimeError, CLError.get()); - - py::register_exception_translator(translate_cl_error); - } - // }}} - - // {{{ constants -#define ADD_ATTR(PREFIX, NAME) \ - cls.attr(#NAME) = CL_##PREFIX##NAME - - { - py::class_ cls("platform_info", py::no_init); - ADD_ATTR(PLATFORM_, PROFILE); - ADD_ATTR(PLATFORM_, VERSION); - ADD_ATTR(PLATFORM_, NAME); - ADD_ATTR(PLATFORM_, VENDOR); -#if !(defined(CL_PLATFORM_NVIDIA) && CL_PLATFORM_NVIDIA == 0x3001) - ADD_ATTR(PLATFORM_, EXTENSIONS); -#endif - } - - { - py::class_ cls("device_type", py::no_init); - ADD_ATTR(DEVICE_TYPE_, DEFAULT); - ADD_ATTR(DEVICE_TYPE_, CPU); - ADD_ATTR(DEVICE_TYPE_, GPU); - ADD_ATTR(DEVICE_TYPE_, ACCELERATOR); - ADD_ATTR(DEVICE_TYPE_, ALL); - } - - { - py::class_ cls("device_info", py::no_init); - ADD_ATTR(DEVICE_, TYPE); - ADD_ATTR(DEVICE_, VENDOR_ID); - ADD_ATTR(DEVICE_, MAX_COMPUTE_UNITS); - ADD_ATTR(DEVICE_, MAX_WORK_ITEM_DIMENSIONS); - ADD_ATTR(DEVICE_, MAX_WORK_GROUP_SIZE); - ADD_ATTR(DEVICE_, MAX_WORK_ITEM_SIZES); - ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_CHAR); - ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_SHORT); - ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_INT); - ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_LONG); - ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_FLOAT); - ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_DOUBLE); - ADD_ATTR(DEVICE_, MAX_CLOCK_FREQUENCY); - ADD_ATTR(DEVICE_, ADDRESS_BITS); - ADD_ATTR(DEVICE_, MAX_READ_IMAGE_ARGS); - ADD_ATTR(DEVICE_, MAX_WRITE_IMAGE_ARGS); - ADD_ATTR(DEVICE_, MAX_MEM_ALLOC_SIZE); - ADD_ATTR(DEVICE_, IMAGE2D_MAX_WIDTH); - ADD_ATTR(DEVICE_, IMAGE2D_MAX_HEIGHT); - ADD_ATTR(DEVICE_, IMAGE3D_MAX_WIDTH); - ADD_ATTR(DEVICE_, IMAGE3D_MAX_HEIGHT); - ADD_ATTR(DEVICE_, IMAGE3D_MAX_DEPTH); - ADD_ATTR(DEVICE_, IMAGE_SUPPORT); - ADD_ATTR(DEVICE_, MAX_PARAMETER_SIZE); - ADD_ATTR(DEVICE_, MAX_SAMPLERS); - ADD_ATTR(DEVICE_, MEM_BASE_ADDR_ALIGN); - ADD_ATTR(DEVICE_, MIN_DATA_TYPE_ALIGN_SIZE); - ADD_ATTR(DEVICE_, SINGLE_FP_CONFIG); - ADD_ATTR(DEVICE_, GLOBAL_MEM_CACHE_TYPE); - ADD_ATTR(DEVICE_, GLOBAL_MEM_CACHELINE_SIZE); - ADD_ATTR(DEVICE_, GLOBAL_MEM_CACHE_SIZE); - ADD_ATTR(DEVICE_, GLOBAL_MEM_SIZE); - ADD_ATTR(DEVICE_, MAX_CONSTANT_BUFFER_SIZE); - ADD_ATTR(DEVICE_, MAX_CONSTANT_ARGS); - ADD_ATTR(DEVICE_, LOCAL_MEM_TYPE); - ADD_ATTR(DEVICE_, LOCAL_MEM_SIZE); - ADD_ATTR(DEVICE_, ERROR_CORRECTION_SUPPORT); - ADD_ATTR(DEVICE_, PROFILING_TIMER_RESOLUTION); - ADD_ATTR(DEVICE_, ENDIAN_LITTLE); - ADD_ATTR(DEVICE_, AVAILABLE); - ADD_ATTR(DEVICE_, COMPILER_AVAILABLE); - ADD_ATTR(DEVICE_, EXECUTION_CAPABILITIES); - ADD_ATTR(DEVICE_, QUEUE_PROPERTIES); - ADD_ATTR(DEVICE_, NAME); - ADD_ATTR(DEVICE_, VENDOR); - ADD_ATTR(DEVICE_, VERSION); - ADD_ATTR(DEVICE_, PROFILE); - ADD_ATTR(DEVICE_, VERSION); - ADD_ATTR(DEVICE_, EXTENSIONS); - ADD_ATTR(DEVICE_, PLATFORM); -#ifdef CL_VERSION_1_1 - ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_HALF); - ADD_ATTR(DEVICE_, HOST_UNIFIED_MEMORY); - ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_CHAR); - ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_SHORT); - ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_INT); - ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_LONG); - ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_FLOAT); - ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_DOUBLE); - ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_HALF); - ADD_ATTR(DEVICE_, OPENCL_C_VERSION); -#endif -// support for cl_nv_device_attribute_query -#ifdef CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV - ADD_ATTR(DEVICE_, COMPUTE_CAPABILITY_MAJOR_NV); - ADD_ATTR(DEVICE_, COMPUTE_CAPABILITY_MINOR_NV); - ADD_ATTR(DEVICE_, REGISTERS_PER_BLOCK_NV); - ADD_ATTR(DEVICE_, WARP_SIZE_NV); - ADD_ATTR(DEVICE_, GPU_OVERLAP_NV); - ADD_ATTR(DEVICE_, KERNEL_EXEC_TIMEOUT_NV); - ADD_ATTR(DEVICE_, INTEGRATED_MEMORY_NV); -#endif - } - - { - py::class_ cls("device_fp_config", py::no_init); - ADD_ATTR(FP_, DENORM); - ADD_ATTR(FP_, INF_NAN); - ADD_ATTR(FP_, ROUND_TO_NEAREST); - ADD_ATTR(FP_, ROUND_TO_ZERO); - ADD_ATTR(FP_, ROUND_TO_INF); - ADD_ATTR(FP_, FMA); -#ifdef CL_VERSION_1_1 - ADD_ATTR(FP_, SOFT_FLOAT); -#endif - } - - { - py::class_ cls("device_mem_cache_type", py::no_init); - ADD_ATTR( , NONE); - ADD_ATTR( , READ_ONLY_CACHE); - ADD_ATTR( , READ_WRITE_CACHE); - } - - { - py::class_ cls("device_local_mem_type", py::no_init); - ADD_ATTR( , LOCAL); - ADD_ATTR( , GLOBAL); - } - - { - py::class_ cls("device_exec_capabilities", py::no_init); - ADD_ATTR(EXEC_, KERNEL); - ADD_ATTR(EXEC_, NATIVE_KERNEL); - } - - { - py::class_ cls("command_queue_properties", py::no_init); - ADD_ATTR(QUEUE_, OUT_OF_ORDER_EXEC_MODE_ENABLE); - ADD_ATTR(QUEUE_, PROFILING_ENABLE); - } - - { - py::class_ cls("context_info", py::no_init); - ADD_ATTR(CONTEXT_, REFERENCE_COUNT); - ADD_ATTR(CONTEXT_, DEVICES); - ADD_ATTR(CONTEXT_, PROPERTIES); -#ifdef CL_VERSION_1_1 - ADD_ATTR(CONTEXT_, NUM_DEVICES); -#endif - } - - { - py::class_ cls("gl_context_info", py::no_init); -#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); -#endif - } - - { - py::class_ cls("context_properties", py::no_init); - ADD_ATTR(CONTEXT_, PLATFORM); -#if defined(cl_khr_gl_sharing) && (cl_khr_gl_sharing >= 1) - ADD_ATTR( ,GL_CONTEXT_KHR); - ADD_ATTR( ,EGL_DISPLAY_KHR); - ADD_ATTR( ,GLX_DISPLAY_KHR); - ADD_ATTR( ,WGL_HDC_KHR); - ADD_ATTR( ,CGL_SHAREGROUP_KHR); -#endif - } - - { - py::class_ cls("command_queue_info", py::no_init); - ADD_ATTR(QUEUE_, CONTEXT); - ADD_ATTR(QUEUE_, DEVICE); - ADD_ATTR(QUEUE_, REFERENCE_COUNT); - ADD_ATTR(QUEUE_, PROPERTIES); - } - - { - py::class_ cls("mem_flags", py::no_init); - ADD_ATTR(MEM_, READ_WRITE); - ADD_ATTR(MEM_, WRITE_ONLY); - ADD_ATTR(MEM_, READ_ONLY); - ADD_ATTR(MEM_, USE_HOST_PTR); - ADD_ATTR(MEM_, ALLOC_HOST_PTR); - ADD_ATTR(MEM_, COPY_HOST_PTR); - } - - { - py::class_ cls("channel_order", py::no_init); - ADD_ATTR( , R); - ADD_ATTR( , A); - ADD_ATTR( , RG); - ADD_ATTR( , RA); - ADD_ATTR( , RGB); - ADD_ATTR( , RGBA); - ADD_ATTR( , BGRA); - ADD_ATTR( , INTENSITY); - ADD_ATTR( , LUMINANCE); -#ifdef CL_VERSION_1_1 - ADD_ATTR( , Rx); - ADD_ATTR( , RGx); - ADD_ATTR( , RGBx); -#endif - } - - { - py::class_ cls("channel_type", py::no_init); - ADD_ATTR( , SNORM_INT8); - ADD_ATTR( , SNORM_INT16); - ADD_ATTR( , UNORM_INT8); - ADD_ATTR( , UNORM_INT16); - ADD_ATTR( , UNORM_SHORT_565); - ADD_ATTR( , UNORM_SHORT_555); - ADD_ATTR( , UNORM_INT_101010); - ADD_ATTR( , SIGNED_INT8); - ADD_ATTR( , SIGNED_INT16); - ADD_ATTR( , SIGNED_INT32); - ADD_ATTR( , UNSIGNED_INT8); - ADD_ATTR( , UNSIGNED_INT16); - ADD_ATTR( , UNSIGNED_INT32); - ADD_ATTR( , HALF_FLOAT); - ADD_ATTR( , FLOAT); - } - - { - py::class_ cls("mem_object_type", py::no_init); - ADD_ATTR(MEM_OBJECT_, BUFFER); - ADD_ATTR(MEM_OBJECT_, IMAGE2D); - ADD_ATTR(MEM_OBJECT_, IMAGE3D); - } - - { - py::class_ cls("mem_info", py::no_init); - ADD_ATTR(MEM_, TYPE); - ADD_ATTR(MEM_, FLAGS); - ADD_ATTR(MEM_, SIZE); - ADD_ATTR(MEM_, HOST_PTR); - ADD_ATTR(MEM_, MAP_COUNT); - ADD_ATTR(MEM_, REFERENCE_COUNT); - ADD_ATTR(MEM_, CONTEXT); -#ifdef CL_VERSION_1_1 - ADD_ATTR(MEM_, ASSOCIATED_MEMOBJECT); - ADD_ATTR(MEM_, OFFSET); -#endif - } - - { - py::class_ cls("image_info", py::no_init); - ADD_ATTR(IMAGE_, FORMAT); - ADD_ATTR(IMAGE_, ELEMENT_SIZE); - ADD_ATTR(IMAGE_, ROW_PITCH); - ADD_ATTR(IMAGE_, SLICE_PITCH); - ADD_ATTR(IMAGE_, WIDTH); - ADD_ATTR(IMAGE_, HEIGHT); - ADD_ATTR(IMAGE_, DEPTH); - } - - { - py::class_ cls("addressing_mode", py::no_init); - ADD_ATTR(ADDRESS_, NONE); - ADD_ATTR(ADDRESS_, CLAMP_TO_EDGE); - ADD_ATTR(ADDRESS_, CLAMP); - ADD_ATTR(ADDRESS_, REPEAT); -#ifdef CL_VERSION_1_1 - ADD_ATTR(ADDRESS_, MIRRORED_REPEAT); -#endif - } - - { - py::class_ cls("filter_mode", py::no_init); - ADD_ATTR(FILTER_, NEAREST); - ADD_ATTR(FILTER_, LINEAR); - } - - { - py::class_ cls("sampler_info", py::no_init); - ADD_ATTR(SAMPLER_, REFERENCE_COUNT); - ADD_ATTR(SAMPLER_, CONTEXT); - ADD_ATTR(SAMPLER_, NORMALIZED_COORDS); - ADD_ATTR(SAMPLER_, ADDRESSING_MODE); - ADD_ATTR(SAMPLER_, FILTER_MODE); - } - - { - py::class_ cls("map_flags", py::no_init); - ADD_ATTR(MAP_, READ); - ADD_ATTR(MAP_, WRITE); - } - - { - py::class_ cls("program_info", py::no_init); - ADD_ATTR(PROGRAM_, REFERENCE_COUNT); - ADD_ATTR(PROGRAM_, CONTEXT); - ADD_ATTR(PROGRAM_, NUM_DEVICES); - ADD_ATTR(PROGRAM_, DEVICES); - ADD_ATTR(PROGRAM_, SOURCE); - ADD_ATTR(PROGRAM_, BINARY_SIZES); - ADD_ATTR(PROGRAM_, BINARIES); - } - - { - py::class_ cls("program_build_info", py::no_init); - ADD_ATTR(PROGRAM_BUILD_, STATUS); - ADD_ATTR(PROGRAM_BUILD_, OPTIONS); - ADD_ATTR(PROGRAM_BUILD_, LOG); - } - - { - py::class_ cls("kernel_info", py::no_init); - ADD_ATTR(KERNEL_, FUNCTION_NAME); - ADD_ATTR(KERNEL_, NUM_ARGS); - ADD_ATTR(KERNEL_, REFERENCE_COUNT); - ADD_ATTR(KERNEL_, CONTEXT); - ADD_ATTR(KERNEL_, PROGRAM); - } - - { - py::class_ cls("kernel_work_group_info", py::no_init); - ADD_ATTR(KERNEL_, WORK_GROUP_SIZE); - ADD_ATTR(KERNEL_, COMPILE_WORK_GROUP_SIZE); - ADD_ATTR(KERNEL_, LOCAL_MEM_SIZE); -#ifdef CL_VERSION_1_1 - ADD_ATTR(KERNEL_, PREFERRED_WORK_GROUP_SIZE_MULTIPLE); - ADD_ATTR(KERNEL_, PRIVATE_MEM_SIZE); -#endif - } - - { - py::class_ cls("event_info", py::no_init); - ADD_ATTR(EVENT_, COMMAND_QUEUE); - ADD_ATTR(EVENT_, COMMAND_TYPE); - ADD_ATTR(EVENT_, REFERENCE_COUNT); - ADD_ATTR(EVENT_, COMMAND_EXECUTION_STATUS); -#ifdef CL_VERSION_1_1 - ADD_ATTR(EVENT_, CONTEXT); -#endif - } - - { - py::class_ cls("command_type", py::no_init); - ADD_ATTR(COMMAND_, NDRANGE_KERNEL); - ADD_ATTR(COMMAND_, TASK); - ADD_ATTR(COMMAND_, NATIVE_KERNEL); - ADD_ATTR(COMMAND_, READ_BUFFER); - ADD_ATTR(COMMAND_, WRITE_BUFFER); - ADD_ATTR(COMMAND_, COPY_BUFFER); - ADD_ATTR(COMMAND_, READ_IMAGE); - ADD_ATTR(COMMAND_, WRITE_IMAGE); - ADD_ATTR(COMMAND_, COPY_IMAGE); - ADD_ATTR(COMMAND_, COPY_IMAGE_TO_BUFFER); - ADD_ATTR(COMMAND_, COPY_BUFFER_TO_IMAGE); - ADD_ATTR(COMMAND_, MAP_BUFFER); - ADD_ATTR(COMMAND_, MAP_IMAGE); - ADD_ATTR(COMMAND_, UNMAP_MEM_OBJECT); - ADD_ATTR(COMMAND_, MARKER); - ADD_ATTR(COMMAND_, ACQUIRE_GL_OBJECTS); - ADD_ATTR(COMMAND_, RELEASE_GL_OBJECTS); -#ifdef CL_VERSION_1_1 - ADD_ATTR(COMMAND_, READ_BUFFER_RECT); - ADD_ATTR(COMMAND_, WRITE_BUFFER_RECT); - ADD_ATTR(COMMAND_, COPY_BUFFER_RECT); - ADD_ATTR(COMMAND_, USER); -#endif - } - - { - py::class_ cls("command_execution_status", py::no_init); - ADD_ATTR(, COMPLETE); - ADD_ATTR(, RUNNING); - ADD_ATTR(, SUBMITTED); - ADD_ATTR(, QUEUED); - } - - { - py::class_ cls("profiling_info", py::no_init); - ADD_ATTR(PROFILING_COMMAND_, QUEUED); - ADD_ATTR(PROFILING_COMMAND_, SUBMIT); - ADD_ATTR(PROFILING_COMMAND_, START); - ADD_ATTR(PROFILING_COMMAND_, END); - } - -/* not needed--filled in automatically by implementation. -#ifdef CL_VERSION_1_1 - { - py::class_ cls("buffer_create_type", py::no_init); - ADD_ATTR(BUFFER_CREATE_TYPE_, REGION); - } -#endif -*/ - - // }}} - - py::def("get_cl_header_version", get_cl_header_version); - - // {{{ platform - DEF_SIMPLE_FUNCTION(get_platforms); - - { - typedef platform cls; - py::class_("Platform", py::no_init) - .DEF_SIMPLE_METHOD(get_info) - .def("get_devices", &cls::get_devices, - py::arg("device_type")=CL_DEVICE_TYPE_ALL) - .add_property("obj_ptr", &cls::obj_ptr) - .def(py::self == py::self) - .def(py::self != py::self) - ; - } - - // }}} - - // {{{ device - { - typedef device cls; - py::class_("Device", py::no_init) - .DEF_SIMPLE_METHOD(get_info) - .add_property("obj_ptr", &cls::obj_ptr) - .def(py::self == py::self) - .def(py::self != py::self) - ; - } - - // }}} - - // {{{ context - - { - typedef context cls; - py::class_("Context", py::no_init) - .def("__init__", make_constructor(create_context, - py::default_call_policies(), - (py::arg("devices")=py::object(), - py::arg("properties")=py::object(), - py::arg("dev_type")=py::object() - ))) - .DEF_SIMPLE_METHOD(get_info) - .add_property("obj_ptr", &cls::obj_ptr) - .def(py::self == py::self) - .def(py::self != py::self) - ; - } - - // }}} - - // {{{ command queue - { - typedef command_queue cls; - py::class_("CommandQueue", - py::init - ((py::arg("context"), py::arg("device")=py::object(), py::arg("properties")=0))) - .DEF_SIMPLE_METHOD(get_info) -#ifndef CL_VERSION_1_1 - .DEF_SIMPLE_METHOD(set_property) -#endif - .DEF_SIMPLE_METHOD(flush) - .DEF_SIMPLE_METHOD(finish) - .add_property("obj_ptr", &cls::obj_ptr) - .def(py::self == py::self) - .def(py::self != py::self) - ; - } - - // }}} - - // {{{ events/synchronization - { - typedef event cls; - py::class_("Event", py::no_init) - .DEF_SIMPLE_METHOD(get_info) - .DEF_SIMPLE_METHOD(get_profiling_info) - .add_property("obj_ptr", &cls::obj_ptr) - .def(py::self == py::self) - .def(py::self != py::self) - ; - } - - DEF_SIMPLE_FUNCTION(wait_for_events); - py::def("enqueue_marker", enqueue_marker, - py::return_value_policy()); - DEF_SIMPLE_FUNCTION(enqueue_wait_for_events); - DEF_SIMPLE_FUNCTION(enqueue_barrier); - -#ifdef CL_VERSION_1_1 - { - typedef user_event cls; - py::class_, boost::noncopyable>("UserEvent", py::no_init) - .def("__init__", make_constructor( - create_user_event, py::default_call_policies(), py::args("context"))) - .DEF_SIMPLE_METHOD(set_status) - ; - } -#endif - - // }}} - - // {{{ memory_object - - { - typedef memory_object cls; - py::class_("MemoryObject", py::no_init) - .DEF_SIMPLE_METHOD(get_info) - .DEF_SIMPLE_METHOD(release) - .add_property("obj_ptr", &cls::obj_ptr) - .add_property("hostbuf", &cls::hostbuf) - .def(py::self == py::self) - .def(py::self != py::self) - ; - } - - // }}} - - // {{{ buffer - { - typedef buffer cls; - py::class_, boost::noncopyable>( - "Buffer", py::no_init) - .def("__init__", make_constructor(create_buffer, - py::default_call_policies(), - (py::args("context", "flags"), - py::arg("size")=0, - py::arg("hostbuf")=py::object() - ))) -#ifdef CL_VERSION_1_1 - .def("get_sub_region", &cls::get_sub_region, - (py::args("origin", "size"), py::arg("flags")=0), - py::return_value_policy()) - .def("__getitem__", &cls::getitem, - py::return_value_policy()) -#endif - ; - } - - // {{{ transfers - - // {{{ byte-for-byte - py::def("enqueue_read_buffer", enqueue_read_buffer, - (py::args("queue", "mem", "hostbuf"), - py::arg("device_offset")=0, - py::arg("wait_for")=py::object(), - py::arg("is_blocking")=false, - py::arg("host_buffer")=py::object() - ), - py::return_value_policy()); - py::def("enqueue_write_buffer", enqueue_write_buffer, - (py::args("queue", "mem", "hostbuf"), - py::arg("device_offset")=0, - py::arg("wait_for")=py::object(), - py::arg("is_blocking")=false, - py::arg("host_buffer")=py::object() - ), - py::return_value_policy()); - py::def("enqueue_copy_buffer", enqueue_copy_buffer, - (py::args("queue", "src", "dst"), - py::arg("byte_count")=0, - py::arg("src_offset")=0, - py::arg("dst_offset")=0, - py::arg("wait_for")=py::object() - ), - py::return_value_policy()); - - // }}} - - // {{{ rectangular - -#ifdef CL_VERSION_1_1 - py::def("enqueue_read_buffer_rect", enqueue_read_buffer_rect, - (py::args("queue", "mem", "hostbuf", - "buffer_origin", "host_origin", "region"), - py::arg("buffer_pitches")=py::object(), - py::arg("host_pitches")=py::object(), - py::arg("wait_for")=py::object(), - py::arg("is_blocking")=false - ), - py::return_value_policy()); - py::def("enqueue_write_buffer_rect", enqueue_write_buffer_rect, - (py::args("queue", "mem", "hostbuf", - "buffer_origin", "host_origin", "region"), - py::arg("buffer_pitches")=py::object(), - py::arg("host_pitches")=py::object(), - py::arg("wait_for")=py::object(), - py::arg("is_blocking")=false - ), - py::return_value_policy()); - py::def("enqueue_copy_buffer_rect", enqueue_copy_buffer_rect, - (py::args("queue", "src", "dst", - "src_origin", "dst_origin", "region"), - py::arg("src_pitches")=py::object(), - py::arg("dst_pitches")=py::object(), - py::arg("wait_for")=py::object() - ), - py::return_value_policy()); -#endif - - // }}} - - // }}} - - // }}} - - // {{{ image - { - typedef image cls; - py::class_, boost::noncopyable>( - "Image", py::no_init) - .def("__init__", make_constructor(create_image, - py::default_call_policies(), - (py::args("context", "flags", "format"), - py::arg("shape")=py::object(), - py::arg("pitches")=py::object(), - py::arg("hostbuf")=py::object(), - py::arg("host_buffer")=py::object() - ))) - .DEF_SIMPLE_METHOD(get_image_info) - ; - } - - { - typedef cl_image_format cls; - py::class_("ImageFormat") - .def("__init__", py::make_constructor(make_image_format)) - .def_readwrite("channel_order", &cls::image_channel_order) - .def_readwrite("channel_data_type", &cls::image_channel_data_type) - .add_property("channel_count", &get_image_format_channel_count) - .add_property("dtype_size", &get_image_format_channel_dtype_size) - .add_property("itemsize", &get_image_format_item_size) - ; - } - - DEF_SIMPLE_FUNCTION(get_supported_image_formats); - - py::def("enqueue_read_image", enqueue_read_image, - (py::args("queue", "mem", "origin", "region", "hostbuf"), - py::arg("row_pitch")=0, - py::arg("slice_pitch")=0, - py::arg("wait_for")=py::object(), - py::arg("is_blocking")=false, - py::arg("host_buffer")=py::object() - ), - py::return_value_policy()); - py::def("enqueue_write_image", enqueue_write_image, - (py::args("queue", "mem", "origin", "region", "hostbuf"), - py::arg("row_pitch")=0, - py::arg("slice_pitch")=0, - py::arg("wait_for")=py::object(), - py::arg("is_blocking")=false, - py::arg("host_buffer")=py::object() - ), - py::return_value_policy()); - - py::def("enqueue_copy_image", enqueue_copy_image, - (py::args("queue", "src", "dest", "src_origin", "dest_origin", "region"), - py::arg("wait_for")=py::object()), - py::return_value_policy()); - py::def("enqueue_copy_image_to_buffer", enqueue_copy_image_to_buffer, - (py::args("queue", "src", "dest", "origin", "region", "offset"), - py::arg("wait_for")=py::object()), - py::return_value_policy()); - py::def("enqueue_copy_buffer_to_image", enqueue_copy_image_to_buffer, - (py::args("queue", "src", "dest", "offset", "origin", "region"), - py::arg("wait_for")=py::object()), - py::return_value_policy()); - - // }}} - - // {{{ memory_map - { - typedef memory_map cls; - py::class_("MemoryMap", py::no_init) - .def("release", &cls::release, - (py::arg("queue")=0, py::arg("wait_for")=py::object()), - py::return_value_policy()) - ; - } - - py::def("enqueue_map_buffer", enqueue_map_buffer, - (py::args("queue", "buf", "flags", - "offset", - "shape", "dtype", "order"), - py::arg("wait_for")=py::object(), - py::arg("is_blocking")=false)); - py::def("enqueue_map_image", enqueue_map_image, - (py::args("queue", "img", "flags", - "origin", "region", - "shape", "dtype", "order"), - py::arg("wait_for")=py::object(), - py::arg("is_blocking")=false)); - - // }}} - - // {{{ sampler - { - typedef sampler cls; - py::class_("Sampler", - py::init()) - .DEF_SIMPLE_METHOD(get_info) - .add_property("obj_ptr", &cls::obj_ptr) - .def(py::self == py::self) - .def(py::self != py::self) - ; - } - - // }}} - - // {{{ program - { - typedef program cls; - py::class_("Program", py::no_init) - .def("__init__", make_constructor( - create_program_with_source, - py::default_call_policies(), - py::args("context", "src"))) - .def("__init__", make_constructor( - create_program_with_binary, - py::default_call_policies(), - py::args("context", "devices", "binaries"))) - .DEF_SIMPLE_METHOD(get_info) - .DEF_SIMPLE_METHOD(get_build_info) - .def("_build", &cls::build, - (py::arg("options")="", py::arg("devices")=py::object())) - .add_property("obj_ptr", &cls::obj_ptr) - .def(py::self == py::self) - .def(py::self != py::self) - .def("all_kernels", create_kernels_in_program) - ; - } - - py::def("unload_compiler", unload_compiler); - - { - typedef kernel cls; - py::class_("Kernel", - py::init()) - .DEF_SIMPLE_METHOD(get_info) - .DEF_SIMPLE_METHOD(get_work_group_info) - .DEF_SIMPLE_METHOD(set_arg) - .add_property("obj_ptr", &cls::obj_ptr) - .def(py::self == py::self) - .def(py::self != py::self) - ; - } - - { - typedef local_memory cls; - py::class_("LocalMemory", - py::init(py::arg("size"))) - .add_property("size", &cls::size) - ; - } - - - py::def("enqueue_nd_range_kernel", enqueue_nd_range_kernel, - (py::args("queue", "kernel"), - py::arg("global_work_size"), - py::arg("local_work_size"), - py::arg("global_work_offset")=py::object(), - py::arg("wait_for")=py::object() - ), - py::return_value_policy()); - py::def("enqueue_task", enqueue_task, - (py::args("queue", "kernel"), - py::arg("wait_for")=py::object() - ), - py::return_value_policy()); - - // TODO: clEnqueueNativeKernel - // }}} - - // {{{ GL interop - DEF_SIMPLE_FUNCTION(have_gl); - -#ifdef HAVE_GL - { - py::class_ cls("gl_object_type", py::no_init); - ADD_ATTR(GL_OBJECT_, BUFFER); - ADD_ATTR(GL_OBJECT_, TEXTURE2D); - ADD_ATTR(GL_OBJECT_, TEXTURE3D); - ADD_ATTR(GL_OBJECT_, RENDERBUFFER); - } - - { - py::class_ cls("gl_texture_info", py::no_init); - ADD_ATTR(GL_, TEXTURE_TARGET); - ADD_ATTR(GL_, MIPMAP_LEVEL); - } - - { - 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::args("context", "flags", "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::args("context", "flags", "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::args("context", "flags", - "texture_target", "miplevel", - "texture", "dims")))) - .def("get_gl_object_info", get_gl_object_info) - .DEF_SIMPLE_METHOD(get_gl_texture_info) - ; - } - - py::def("enqueue_acquire_gl_objects", enqueue_acquire_gl_objects, - (py::args("queue", "mem_objects"), - py::arg("wait_for")=py::object() - ), - py::return_value_policy()); - py::def("enqueue_release_gl_objects", enqueue_release_gl_objects, - (py::args("queue", "mem_objects"), - py::arg("wait_for")=py::object() - ), - py::return_value_policy()); - - py::def("get_gl_context_info_khr", get_gl_context_info_khr, - py::args("properties", "param_name")); - -#endif - // }}} + pyopencl_expose_constants(); + pyopencl_expose_part_1(); + pyopencl_expose_part_2(); } // vim: foldmethod=marker diff --git a/src/wrapper/wrap_cl.hpp b/src/wrapper/wrap_cl.hpp index 2a462764..b12286c9 100644 --- a/src/wrapper/wrap_cl.hpp +++ b/src/wrapper/wrap_cl.hpp @@ -1552,6 +1552,7 @@ namespace pyopencl return result.release(); } + inline py::list get_supported_image_formats( context const &ctx, cl_mem_flags flags, @@ -2700,6 +2701,7 @@ namespace pyopencl // }}} // {{{ gl interop + inline bool have_gl() { #ifdef HAVE_GL @@ -2804,6 +2806,7 @@ namespace pyopencl (context &ctx, cl_mem_flags flags, GLuint renderbuffer), (ctx.data(), flags, renderbuffer, &status_code)); + inline gl_texture *create_from_gl_texture( context &ctx, cl_mem_flags flags, GLenum texture_target, GLint miplevel, diff --git a/src/wrapper/wrap_cl_part_1.cpp b/src/wrapper/wrap_cl_part_1.cpp new file mode 100644 index 00000000..21476153 --- /dev/null +++ b/src/wrapper/wrap_cl_part_1.cpp @@ -0,0 +1,222 @@ +#include "wrap_cl.hpp" + + + + +using namespace pyopencl; + + + + +void pyopencl_expose_part_1() +{ + py::def("get_cl_header_version", get_cl_header_version); + + // {{{ platform + DEF_SIMPLE_FUNCTION(get_platforms); + + { + typedef platform cls; + py::class_("Platform", py::no_init) + .DEF_SIMPLE_METHOD(get_info) + .def("get_devices", &cls::get_devices, + py::arg("device_type")=CL_DEVICE_TYPE_ALL) + .add_property("obj_ptr", &cls::obj_ptr) + .def(py::self == py::self) + .def(py::self != py::self) + ; + } + + // }}} + + // {{{ device + { + typedef device cls; + py::class_("Device", py::no_init) + .DEF_SIMPLE_METHOD(get_info) + .add_property("obj_ptr", &cls::obj_ptr) + .def(py::self == py::self) + .def(py::self != py::self) + ; + } + + // }}} + + // {{{ context + + { + typedef context cls; + py::class_("Context", py::no_init) + .def("__init__", make_constructor(create_context, + py::default_call_policies(), + (py::arg("devices")=py::object(), + py::arg("properties")=py::object(), + py::arg("dev_type")=py::object() + ))) + .DEF_SIMPLE_METHOD(get_info) + .add_property("obj_ptr", &cls::obj_ptr) + .def(py::self == py::self) + .def(py::self != py::self) + ; + } + + // }}} + + // {{{ command queue + { + typedef command_queue cls; + py::class_("CommandQueue", + py::init + ((py::arg("context"), py::arg("device")=py::object(), py::arg("properties")=0))) + .DEF_SIMPLE_METHOD(get_info) +#ifndef CL_VERSION_1_1 + .DEF_SIMPLE_METHOD(set_property) +#endif + .DEF_SIMPLE_METHOD(flush) + .DEF_SIMPLE_METHOD(finish) + .add_property("obj_ptr", &cls::obj_ptr) + .def(py::self == py::self) + .def(py::self != py::self) + ; + } + + // }}} + + // {{{ events/synchronization + { + typedef event cls; + py::class_("Event", py::no_init) + .DEF_SIMPLE_METHOD(get_info) + .DEF_SIMPLE_METHOD(get_profiling_info) + .add_property("obj_ptr", &cls::obj_ptr) + .def(py::self == py::self) + .def(py::self != py::self) + ; + } + + DEF_SIMPLE_FUNCTION(wait_for_events); + py::def("enqueue_marker", enqueue_marker, + py::return_value_policy()); + DEF_SIMPLE_FUNCTION(enqueue_wait_for_events); + DEF_SIMPLE_FUNCTION(enqueue_barrier); + +#ifdef CL_VERSION_1_1 + { + typedef user_event cls; + py::class_, boost::noncopyable>("UserEvent", py::no_init) + .def("__init__", make_constructor( + create_user_event, py::default_call_policies(), py::args("context"))) + .DEF_SIMPLE_METHOD(set_status) + ; + } +#endif + + // }}} + + // {{{ memory_object + + { + typedef memory_object cls; + py::class_("MemoryObject", py::no_init) + .DEF_SIMPLE_METHOD(get_info) + .DEF_SIMPLE_METHOD(release) + .add_property("obj_ptr", &cls::obj_ptr) + .add_property("hostbuf", &cls::hostbuf) + .def(py::self == py::self) + .def(py::self != py::self) + ; + } + + // }}} + + // {{{ buffer + { + typedef buffer cls; + py::class_, boost::noncopyable>( + "Buffer", py::no_init) + .def("__init__", make_constructor(create_buffer, + py::default_call_policies(), + (py::args("context", "flags"), + py::arg("size")=0, + py::arg("hostbuf")=py::object() + ))) +#ifdef CL_VERSION_1_1 + .def("get_sub_region", &cls::get_sub_region, + (py::args("origin", "size"), py::arg("flags")=0), + py::return_value_policy()) + .def("__getitem__", &cls::getitem, + py::return_value_policy()) +#endif + ; + } + + // {{{ transfers + + // {{{ byte-for-byte + py::def("enqueue_read_buffer", enqueue_read_buffer, + (py::args("queue", "mem", "hostbuf"), + py::arg("device_offset")=0, + py::arg("wait_for")=py::object(), + py::arg("is_blocking")=false, + py::arg("host_buffer")=py::object() + ), + py::return_value_policy()); + py::def("enqueue_write_buffer", enqueue_write_buffer, + (py::args("queue", "mem", "hostbuf"), + py::arg("device_offset")=0, + py::arg("wait_for")=py::object(), + py::arg("is_blocking")=false, + py::arg("host_buffer")=py::object() + ), + py::return_value_policy()); + py::def("enqueue_copy_buffer", enqueue_copy_buffer, + (py::args("queue", "src", "dst"), + py::arg("byte_count")=0, + py::arg("src_offset")=0, + py::arg("dst_offset")=0, + py::arg("wait_for")=py::object() + ), + py::return_value_policy()); + + // }}} + + // {{{ rectangular + +#ifdef CL_VERSION_1_1 + py::def("enqueue_read_buffer_rect", enqueue_read_buffer_rect, + (py::args("queue", "mem", "hostbuf", + "buffer_origin", "host_origin", "region"), + py::arg("buffer_pitches")=py::object(), + py::arg("host_pitches")=py::object(), + py::arg("wait_for")=py::object(), + py::arg("is_blocking")=false + ), + py::return_value_policy()); + py::def("enqueue_write_buffer_rect", enqueue_write_buffer_rect, + (py::args("queue", "mem", "hostbuf", + "buffer_origin", "host_origin", "region"), + py::arg("buffer_pitches")=py::object(), + py::arg("host_pitches")=py::object(), + py::arg("wait_for")=py::object(), + py::arg("is_blocking")=false + ), + py::return_value_policy()); + py::def("enqueue_copy_buffer_rect", enqueue_copy_buffer_rect, + (py::args("queue", "src", "dst", + "src_origin", "dst_origin", "region"), + py::arg("src_pitches")=py::object(), + py::arg("dst_pitches")=py::object(), + py::arg("wait_for")=py::object() + ), + py::return_value_policy()); +#endif + + // }}} + + // }}} + + // }}} +} + +// vim: foldmethod=marker diff --git a/src/wrapper/wrap_cl_part_2.cpp b/src/wrapper/wrap_cl_part_2.cpp new file mode 100644 index 00000000..80a39472 --- /dev/null +++ b/src/wrapper/wrap_cl_part_2.cpp @@ -0,0 +1,242 @@ +#include "wrap_cl.hpp" + + + + +using namespace pyopencl; + + + + +void pyopencl_expose_part_2() +{ + // {{{ image + { + typedef image cls; + py::class_, boost::noncopyable>( + "Image", py::no_init) + .def("__init__", make_constructor(create_image, + py::default_call_policies(), + (py::args("context", "flags", "format"), + py::arg("shape")=py::object(), + py::arg("pitches")=py::object(), + py::arg("hostbuf")=py::object(), + py::arg("host_buffer")=py::object() + ))) + .DEF_SIMPLE_METHOD(get_image_info) + ; + } + + { + typedef cl_image_format cls; + py::class_("ImageFormat") + .def("__init__", py::make_constructor(make_image_format)) + .def_readwrite("channel_order", &cls::image_channel_order) + .def_readwrite("channel_data_type", &cls::image_channel_data_type) + .add_property("channel_count", &get_image_format_channel_count) + .add_property("dtype_size", &get_image_format_channel_dtype_size) + .add_property("itemsize", &get_image_format_item_size) + ; + } + + DEF_SIMPLE_FUNCTION(get_supported_image_formats); + + py::def("enqueue_read_image", enqueue_read_image, + (py::args("queue", "mem", "origin", "region", "hostbuf"), + py::arg("row_pitch")=0, + py::arg("slice_pitch")=0, + py::arg("wait_for")=py::object(), + py::arg("is_blocking")=false, + py::arg("host_buffer")=py::object() + ), + py::return_value_policy()); + py::def("enqueue_write_image", enqueue_write_image, + (py::args("queue", "mem", "origin", "region", "hostbuf"), + py::arg("row_pitch")=0, + py::arg("slice_pitch")=0, + py::arg("wait_for")=py::object(), + py::arg("is_blocking")=false, + py::arg("host_buffer")=py::object() + ), + py::return_value_policy()); + + py::def("enqueue_copy_image", enqueue_copy_image, + (py::args("queue", "src", "dest", "src_origin", "dest_origin", "region"), + py::arg("wait_for")=py::object()), + py::return_value_policy()); + py::def("enqueue_copy_image_to_buffer", enqueue_copy_image_to_buffer, + (py::args("queue", "src", "dest", "origin", "region", "offset"), + py::arg("wait_for")=py::object()), + py::return_value_policy()); + py::def("enqueue_copy_buffer_to_image", enqueue_copy_image_to_buffer, + (py::args("queue", "src", "dest", "offset", "origin", "region"), + py::arg("wait_for")=py::object()), + py::return_value_policy()); + + // }}} + + // {{{ memory_map + { + typedef memory_map cls; + py::class_("MemoryMap", py::no_init) + .def("release", &cls::release, + (py::arg("queue")=0, py::arg("wait_for")=py::object()), + py::return_value_policy()) + ; + } + + py::def("enqueue_map_buffer", enqueue_map_buffer, + (py::args("queue", "buf", "flags", + "offset", + "shape", "dtype", "order"), + py::arg("wait_for")=py::object(), + py::arg("is_blocking")=false)); + py::def("enqueue_map_image", enqueue_map_image, + (py::args("queue", "img", "flags", + "origin", "region", + "shape", "dtype", "order"), + py::arg("wait_for")=py::object(), + py::arg("is_blocking")=false)); + + // }}} + + // {{{ sampler + { + typedef sampler cls; + py::class_("Sampler", + py::init()) + .DEF_SIMPLE_METHOD(get_info) + .add_property("obj_ptr", &cls::obj_ptr) + .def(py::self == py::self) + .def(py::self != py::self) + ; + } + + // }}} + + // {{{ program + { + typedef program cls; + py::class_("Program", py::no_init) + .def("__init__", make_constructor( + create_program_with_source, + py::default_call_policies(), + py::args("context", "src"))) + .def("__init__", make_constructor( + create_program_with_binary, + py::default_call_policies(), + py::args("context", "devices", "binaries"))) + .DEF_SIMPLE_METHOD(get_info) + .DEF_SIMPLE_METHOD(get_build_info) + .def("_build", &cls::build, + (py::arg("options")="", py::arg("devices")=py::object())) + .add_property("obj_ptr", &cls::obj_ptr) + .def(py::self == py::self) + .def(py::self != py::self) + .def("all_kernels", create_kernels_in_program) + ; + } + + py::def("unload_compiler", unload_compiler); + + { + typedef kernel cls; + py::class_("Kernel", + py::init()) + .DEF_SIMPLE_METHOD(get_info) + .DEF_SIMPLE_METHOD(get_work_group_info) + .DEF_SIMPLE_METHOD(set_arg) + .add_property("obj_ptr", &cls::obj_ptr) + .def(py::self == py::self) + .def(py::self != py::self) + ; + } + + { + typedef local_memory cls; + py::class_("LocalMemory", + py::init(py::arg("size"))) + .add_property("size", &cls::size) + ; + } + + + py::def("enqueue_nd_range_kernel", enqueue_nd_range_kernel, + (py::args("queue", "kernel"), + py::arg("global_work_size"), + py::arg("local_work_size"), + py::arg("global_work_offset")=py::object(), + py::arg("wait_for")=py::object() + ), + py::return_value_policy()); + py::def("enqueue_task", enqueue_task, + (py::args("queue", "kernel"), + py::arg("wait_for")=py::object() + ), + py::return_value_policy()); + + // TODO: clEnqueueNativeKernel + // }}} + + // {{{ GL interop + DEF_SIMPLE_FUNCTION(have_gl); + +#ifdef HAVE_GL + { + 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::args("context", "flags", "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::args("context", "flags", "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::args("context", "flags", + "texture_target", "miplevel", + "texture", "dims")))) + .def("get_gl_object_info", get_gl_object_info) + .DEF_SIMPLE_METHOD(get_gl_texture_info) + ; + } + + py::def("enqueue_acquire_gl_objects", enqueue_acquire_gl_objects, + (py::args("queue", "mem_objects"), + py::arg("wait_for")=py::object() + ), + py::return_value_policy()); + py::def("enqueue_release_gl_objects", enqueue_release_gl_objects, + (py::args("queue", "mem_objects"), + py::arg("wait_for")=py::object() + ), + py::return_value_policy()); + + py::def("get_gl_context_info_khr", get_gl_context_info_khr, + py::args("properties", "param_name")); + +#endif + // }}} +} + + + + +// vim: foldmethod=marker diff --git a/src/wrapper/wrap_constants.cpp b/src/wrapper/wrap_constants.cpp new file mode 100644 index 00000000..4f2548bd --- /dev/null +++ b/src/wrapper/wrap_constants.cpp @@ -0,0 +1,510 @@ +#include "wrap_cl.hpp" + + + + +using namespace pyopencl; + + + + +namespace +{ + py::handle<> + CLError, + CLMemoryError, + CLLogicError, + CLRuntimeError; + + + + + void translate_cl_error(const error &err) + { + if (err.code() == CL_MEM_OBJECT_ALLOCATION_FAILURE) + PyErr_SetString(CLMemoryError.get(), err.what()); + else if (err.code() <= CL_INVALID_VALUE) + PyErr_SetString(CLLogicError.get(), err.what()); + else if (err.code() > CL_INVALID_VALUE && err.code() < CL_SUCCESS) + PyErr_SetString(CLRuntimeError.get(), err.what()); + else + PyErr_SetString(CLError.get(), err.what()); + } + + + + + // {{{ 'fake' constant scopes + class platform_info { }; + class device_type { }; + class device_info { }; + class device_fp_config { }; + class device_mem_cache_type { }; + class device_local_mem_type { }; + class device_exec_capabilities { }; + class command_queue_properties { }; + class context_info { }; + class gl_context_info { }; + class context_properties { }; + class command_queue_info { }; + class mem_flags { }; + class channel_order { }; + class channel_type { }; + class mem_object_type { }; + class mem_info { }; + class image_info { }; + class addressing_mode { }; + class filter_mode { }; + class sampler_info { }; + class map_flags { }; + class program_info { }; + class program_build_info { }; + class build_status { }; + class kernel_info { }; + class kernel_work_group_info { }; + class event_info { }; + class command_type { }; + class command_execution_status { }; + class profiling_info { }; + class buffer_create_type { }; + + class gl_object_type { }; + class gl_texture_info { }; + // }}} +} + + + + +void pyopencl_expose_constants() +{ + // {{{ exceptions +#define DECLARE_EXC(NAME, BASE) \ + CL##NAME = py::handle<>(PyErr_NewException("pyopencl." #NAME, BASE, NULL)); \ + py::scope().attr(#NAME) = CL##NAME; + + { + DECLARE_EXC(Error, NULL); + py::tuple memerr_bases = py::make_tuple( + CLError, + py::handle<>(py::borrowed(PyExc_MemoryError))); + DECLARE_EXC(MemoryError, memerr_bases.ptr()); + DECLARE_EXC(LogicError, CLLogicError.get()); + DECLARE_EXC(RuntimeError, CLError.get()); + + py::register_exception_translator(translate_cl_error); + } + // }}} + + // {{{ constants +#define ADD_ATTR(PREFIX, NAME) \ + cls.attr(#NAME) = CL_##PREFIX##NAME + + { + py::class_ cls("platform_info", py::no_init); + ADD_ATTR(PLATFORM_, PROFILE); + ADD_ATTR(PLATFORM_, VERSION); + ADD_ATTR(PLATFORM_, NAME); + ADD_ATTR(PLATFORM_, VENDOR); +#if !(defined(CL_PLATFORM_NVIDIA) && CL_PLATFORM_NVIDIA == 0x3001) + ADD_ATTR(PLATFORM_, EXTENSIONS); +#endif + } + + { + py::class_ cls("device_type", py::no_init); + ADD_ATTR(DEVICE_TYPE_, DEFAULT); + ADD_ATTR(DEVICE_TYPE_, CPU); + ADD_ATTR(DEVICE_TYPE_, GPU); + ADD_ATTR(DEVICE_TYPE_, ACCELERATOR); + ADD_ATTR(DEVICE_TYPE_, ALL); + } + + { + py::class_ cls("device_info", py::no_init); + ADD_ATTR(DEVICE_, TYPE); + ADD_ATTR(DEVICE_, VENDOR_ID); + ADD_ATTR(DEVICE_, MAX_COMPUTE_UNITS); + ADD_ATTR(DEVICE_, MAX_WORK_ITEM_DIMENSIONS); + ADD_ATTR(DEVICE_, MAX_WORK_GROUP_SIZE); + ADD_ATTR(DEVICE_, MAX_WORK_ITEM_SIZES); + ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_CHAR); + ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_SHORT); + ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_INT); + ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_LONG); + ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_FLOAT); + ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_DOUBLE); + ADD_ATTR(DEVICE_, MAX_CLOCK_FREQUENCY); + ADD_ATTR(DEVICE_, ADDRESS_BITS); + ADD_ATTR(DEVICE_, MAX_READ_IMAGE_ARGS); + ADD_ATTR(DEVICE_, MAX_WRITE_IMAGE_ARGS); + ADD_ATTR(DEVICE_, MAX_MEM_ALLOC_SIZE); + ADD_ATTR(DEVICE_, IMAGE2D_MAX_WIDTH); + ADD_ATTR(DEVICE_, IMAGE2D_MAX_HEIGHT); + ADD_ATTR(DEVICE_, IMAGE3D_MAX_WIDTH); + ADD_ATTR(DEVICE_, IMAGE3D_MAX_HEIGHT); + ADD_ATTR(DEVICE_, IMAGE3D_MAX_DEPTH); + ADD_ATTR(DEVICE_, IMAGE_SUPPORT); + ADD_ATTR(DEVICE_, MAX_PARAMETER_SIZE); + ADD_ATTR(DEVICE_, MAX_SAMPLERS); + ADD_ATTR(DEVICE_, MEM_BASE_ADDR_ALIGN); + ADD_ATTR(DEVICE_, MIN_DATA_TYPE_ALIGN_SIZE); + ADD_ATTR(DEVICE_, SINGLE_FP_CONFIG); + ADD_ATTR(DEVICE_, GLOBAL_MEM_CACHE_TYPE); + ADD_ATTR(DEVICE_, GLOBAL_MEM_CACHELINE_SIZE); + ADD_ATTR(DEVICE_, GLOBAL_MEM_CACHE_SIZE); + ADD_ATTR(DEVICE_, GLOBAL_MEM_SIZE); + ADD_ATTR(DEVICE_, MAX_CONSTANT_BUFFER_SIZE); + ADD_ATTR(DEVICE_, MAX_CONSTANT_ARGS); + ADD_ATTR(DEVICE_, LOCAL_MEM_TYPE); + ADD_ATTR(DEVICE_, LOCAL_MEM_SIZE); + ADD_ATTR(DEVICE_, ERROR_CORRECTION_SUPPORT); + ADD_ATTR(DEVICE_, PROFILING_TIMER_RESOLUTION); + ADD_ATTR(DEVICE_, ENDIAN_LITTLE); + ADD_ATTR(DEVICE_, AVAILABLE); + ADD_ATTR(DEVICE_, COMPILER_AVAILABLE); + ADD_ATTR(DEVICE_, EXECUTION_CAPABILITIES); + ADD_ATTR(DEVICE_, QUEUE_PROPERTIES); + ADD_ATTR(DEVICE_, NAME); + ADD_ATTR(DEVICE_, VENDOR); + ADD_ATTR(DEVICE_, VERSION); + ADD_ATTR(DEVICE_, PROFILE); + ADD_ATTR(DEVICE_, VERSION); + ADD_ATTR(DEVICE_, EXTENSIONS); + ADD_ATTR(DEVICE_, PLATFORM); +#ifdef CL_VERSION_1_1 + ADD_ATTR(DEVICE_, PREFERRED_VECTOR_WIDTH_HALF); + ADD_ATTR(DEVICE_, HOST_UNIFIED_MEMORY); + ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_CHAR); + ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_SHORT); + ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_INT); + ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_LONG); + ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_FLOAT); + ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_DOUBLE); + ADD_ATTR(DEVICE_, NATIVE_VECTOR_WIDTH_HALF); + ADD_ATTR(DEVICE_, OPENCL_C_VERSION); +#endif +// support for cl_nv_device_attribute_query +#ifdef CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV + ADD_ATTR(DEVICE_, COMPUTE_CAPABILITY_MAJOR_NV); + ADD_ATTR(DEVICE_, COMPUTE_CAPABILITY_MINOR_NV); + ADD_ATTR(DEVICE_, REGISTERS_PER_BLOCK_NV); + ADD_ATTR(DEVICE_, WARP_SIZE_NV); + ADD_ATTR(DEVICE_, GPU_OVERLAP_NV); + ADD_ATTR(DEVICE_, KERNEL_EXEC_TIMEOUT_NV); + ADD_ATTR(DEVICE_, INTEGRATED_MEMORY_NV); +#endif + } + + { + py::class_ cls("device_fp_config", py::no_init); + ADD_ATTR(FP_, DENORM); + ADD_ATTR(FP_, INF_NAN); + ADD_ATTR(FP_, ROUND_TO_NEAREST); + ADD_ATTR(FP_, ROUND_TO_ZERO); + ADD_ATTR(FP_, ROUND_TO_INF); + ADD_ATTR(FP_, FMA); +#ifdef CL_VERSION_1_1 + ADD_ATTR(FP_, SOFT_FLOAT); +#endif + } + + { + py::class_ cls("device_mem_cache_type", py::no_init); + ADD_ATTR( , NONE); + ADD_ATTR( , READ_ONLY_CACHE); + ADD_ATTR( , READ_WRITE_CACHE); + } + + { + py::class_ cls("device_local_mem_type", py::no_init); + ADD_ATTR( , LOCAL); + ADD_ATTR( , GLOBAL); + } + + { + py::class_ cls("device_exec_capabilities", py::no_init); + ADD_ATTR(EXEC_, KERNEL); + ADD_ATTR(EXEC_, NATIVE_KERNEL); + } + + { + py::class_ cls("command_queue_properties", py::no_init); + ADD_ATTR(QUEUE_, OUT_OF_ORDER_EXEC_MODE_ENABLE); + ADD_ATTR(QUEUE_, PROFILING_ENABLE); + } + + { + py::class_ cls("context_info", py::no_init); + ADD_ATTR(CONTEXT_, REFERENCE_COUNT); + ADD_ATTR(CONTEXT_, DEVICES); + ADD_ATTR(CONTEXT_, PROPERTIES); +#ifdef CL_VERSION_1_1 + ADD_ATTR(CONTEXT_, NUM_DEVICES); +#endif + } + + { + py::class_ cls("gl_context_info", py::no_init); +#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); +#endif + } + + { + py::class_ cls("context_properties", py::no_init); + ADD_ATTR(CONTEXT_, PLATFORM); +#if defined(cl_khr_gl_sharing) && (cl_khr_gl_sharing >= 1) + ADD_ATTR( ,GL_CONTEXT_KHR); + ADD_ATTR( ,EGL_DISPLAY_KHR); + ADD_ATTR( ,GLX_DISPLAY_KHR); + ADD_ATTR( ,WGL_HDC_KHR); + ADD_ATTR( ,CGL_SHAREGROUP_KHR); +#endif + } + + { + py::class_ cls("command_queue_info", py::no_init); + ADD_ATTR(QUEUE_, CONTEXT); + ADD_ATTR(QUEUE_, DEVICE); + ADD_ATTR(QUEUE_, REFERENCE_COUNT); + ADD_ATTR(QUEUE_, PROPERTIES); + } + + { + py::class_ cls("mem_flags", py::no_init); + ADD_ATTR(MEM_, READ_WRITE); + ADD_ATTR(MEM_, WRITE_ONLY); + ADD_ATTR(MEM_, READ_ONLY); + ADD_ATTR(MEM_, USE_HOST_PTR); + ADD_ATTR(MEM_, ALLOC_HOST_PTR); + ADD_ATTR(MEM_, COPY_HOST_PTR); + } + + { + py::class_ cls("channel_order", py::no_init); + ADD_ATTR( , R); + ADD_ATTR( , A); + ADD_ATTR( , RG); + ADD_ATTR( , RA); + ADD_ATTR( , RGB); + ADD_ATTR( , RGBA); + ADD_ATTR( , BGRA); + ADD_ATTR( , INTENSITY); + ADD_ATTR( , LUMINANCE); +#ifdef CL_VERSION_1_1 + ADD_ATTR( , Rx); + ADD_ATTR( , RGx); + ADD_ATTR( , RGBx); +#endif + } + + { + py::class_ cls("channel_type", py::no_init); + ADD_ATTR( , SNORM_INT8); + ADD_ATTR( , SNORM_INT16); + ADD_ATTR( , UNORM_INT8); + ADD_ATTR( , UNORM_INT16); + ADD_ATTR( , UNORM_SHORT_565); + ADD_ATTR( , UNORM_SHORT_555); + ADD_ATTR( , UNORM_INT_101010); + ADD_ATTR( , SIGNED_INT8); + ADD_ATTR( , SIGNED_INT16); + ADD_ATTR( , SIGNED_INT32); + ADD_ATTR( , UNSIGNED_INT8); + ADD_ATTR( , UNSIGNED_INT16); + ADD_ATTR( , UNSIGNED_INT32); + ADD_ATTR( , HALF_FLOAT); + ADD_ATTR( , FLOAT); + } + + { + py::class_ cls("mem_object_type", py::no_init); + ADD_ATTR(MEM_OBJECT_, BUFFER); + ADD_ATTR(MEM_OBJECT_, IMAGE2D); + ADD_ATTR(MEM_OBJECT_, IMAGE3D); + } + + { + py::class_ cls("mem_info", py::no_init); + ADD_ATTR(MEM_, TYPE); + ADD_ATTR(MEM_, FLAGS); + ADD_ATTR(MEM_, SIZE); + ADD_ATTR(MEM_, HOST_PTR); + ADD_ATTR(MEM_, MAP_COUNT); + ADD_ATTR(MEM_, REFERENCE_COUNT); + ADD_ATTR(MEM_, CONTEXT); +#ifdef CL_VERSION_1_1 + ADD_ATTR(MEM_, ASSOCIATED_MEMOBJECT); + ADD_ATTR(MEM_, OFFSET); +#endif + } + + { + py::class_ cls("image_info", py::no_init); + ADD_ATTR(IMAGE_, FORMAT); + ADD_ATTR(IMAGE_, ELEMENT_SIZE); + ADD_ATTR(IMAGE_, ROW_PITCH); + ADD_ATTR(IMAGE_, SLICE_PITCH); + ADD_ATTR(IMAGE_, WIDTH); + ADD_ATTR(IMAGE_, HEIGHT); + ADD_ATTR(IMAGE_, DEPTH); + } + + { + py::class_ cls("addressing_mode", py::no_init); + ADD_ATTR(ADDRESS_, NONE); + ADD_ATTR(ADDRESS_, CLAMP_TO_EDGE); + ADD_ATTR(ADDRESS_, CLAMP); + ADD_ATTR(ADDRESS_, REPEAT); +#ifdef CL_VERSION_1_1 + ADD_ATTR(ADDRESS_, MIRRORED_REPEAT); +#endif + } + + { + py::class_ cls("filter_mode", py::no_init); + ADD_ATTR(FILTER_, NEAREST); + ADD_ATTR(FILTER_, LINEAR); + } + + { + py::class_ cls("sampler_info", py::no_init); + ADD_ATTR(SAMPLER_, REFERENCE_COUNT); + ADD_ATTR(SAMPLER_, CONTEXT); + ADD_ATTR(SAMPLER_, NORMALIZED_COORDS); + ADD_ATTR(SAMPLER_, ADDRESSING_MODE); + ADD_ATTR(SAMPLER_, FILTER_MODE); + } + + { + py::class_ cls("map_flags", py::no_init); + ADD_ATTR(MAP_, READ); + ADD_ATTR(MAP_, WRITE); + } + + { + py::class_ cls("program_info", py::no_init); + ADD_ATTR(PROGRAM_, REFERENCE_COUNT); + ADD_ATTR(PROGRAM_, CONTEXT); + ADD_ATTR(PROGRAM_, NUM_DEVICES); + ADD_ATTR(PROGRAM_, DEVICES); + ADD_ATTR(PROGRAM_, SOURCE); + ADD_ATTR(PROGRAM_, BINARY_SIZES); + ADD_ATTR(PROGRAM_, BINARIES); + } + + { + py::class_ cls("program_build_info", py::no_init); + ADD_ATTR(PROGRAM_BUILD_, STATUS); + ADD_ATTR(PROGRAM_BUILD_, OPTIONS); + ADD_ATTR(PROGRAM_BUILD_, LOG); + } + + { + py::class_ cls("kernel_info", py::no_init); + ADD_ATTR(KERNEL_, FUNCTION_NAME); + ADD_ATTR(KERNEL_, NUM_ARGS); + ADD_ATTR(KERNEL_, REFERENCE_COUNT); + ADD_ATTR(KERNEL_, CONTEXT); + ADD_ATTR(KERNEL_, PROGRAM); + } + + { + py::class_ cls("kernel_work_group_info", py::no_init); + ADD_ATTR(KERNEL_, WORK_GROUP_SIZE); + ADD_ATTR(KERNEL_, COMPILE_WORK_GROUP_SIZE); + ADD_ATTR(KERNEL_, LOCAL_MEM_SIZE); +#ifdef CL_VERSION_1_1 + ADD_ATTR(KERNEL_, PREFERRED_WORK_GROUP_SIZE_MULTIPLE); + ADD_ATTR(KERNEL_, PRIVATE_MEM_SIZE); +#endif + } + + { + py::class_ cls("event_info", py::no_init); + ADD_ATTR(EVENT_, COMMAND_QUEUE); + ADD_ATTR(EVENT_, COMMAND_TYPE); + ADD_ATTR(EVENT_, REFERENCE_COUNT); + ADD_ATTR(EVENT_, COMMAND_EXECUTION_STATUS); +#ifdef CL_VERSION_1_1 + ADD_ATTR(EVENT_, CONTEXT); +#endif + } + + { + py::class_ cls("command_type", py::no_init); + ADD_ATTR(COMMAND_, NDRANGE_KERNEL); + ADD_ATTR(COMMAND_, TASK); + ADD_ATTR(COMMAND_, NATIVE_KERNEL); + ADD_ATTR(COMMAND_, READ_BUFFER); + ADD_ATTR(COMMAND_, WRITE_BUFFER); + ADD_ATTR(COMMAND_, COPY_BUFFER); + ADD_ATTR(COMMAND_, READ_IMAGE); + ADD_ATTR(COMMAND_, WRITE_IMAGE); + ADD_ATTR(COMMAND_, COPY_IMAGE); + ADD_ATTR(COMMAND_, COPY_IMAGE_TO_BUFFER); + ADD_ATTR(COMMAND_, COPY_BUFFER_TO_IMAGE); + ADD_ATTR(COMMAND_, MAP_BUFFER); + ADD_ATTR(COMMAND_, MAP_IMAGE); + ADD_ATTR(COMMAND_, UNMAP_MEM_OBJECT); + ADD_ATTR(COMMAND_, MARKER); + ADD_ATTR(COMMAND_, ACQUIRE_GL_OBJECTS); + ADD_ATTR(COMMAND_, RELEASE_GL_OBJECTS); +#ifdef CL_VERSION_1_1 + ADD_ATTR(COMMAND_, READ_BUFFER_RECT); + ADD_ATTR(COMMAND_, WRITE_BUFFER_RECT); + ADD_ATTR(COMMAND_, COPY_BUFFER_RECT); + ADD_ATTR(COMMAND_, USER); +#endif + } + + { + py::class_ cls("command_execution_status", py::no_init); + ADD_ATTR(, COMPLETE); + ADD_ATTR(, RUNNING); + ADD_ATTR(, SUBMITTED); + ADD_ATTR(, QUEUED); + } + + { + py::class_ cls("profiling_info", py::no_init); + ADD_ATTR(PROFILING_COMMAND_, QUEUED); + ADD_ATTR(PROFILING_COMMAND_, SUBMIT); + ADD_ATTR(PROFILING_COMMAND_, START); + ADD_ATTR(PROFILING_COMMAND_, END); + } + +/* not needed--filled in automatically by implementation. +#ifdef CL_VERSION_1_1 + { + py::class_ cls("buffer_create_type", py::no_init); + ADD_ATTR(BUFFER_CREATE_TYPE_, REGION); + } +#endif +*/ + +#ifdef HAVE_GL + { + py::class_ cls("gl_object_type", py::no_init); + ADD_ATTR(GL_OBJECT_, BUFFER); + ADD_ATTR(GL_OBJECT_, TEXTURE2D); + ADD_ATTR(GL_OBJECT_, TEXTURE3D); + ADD_ATTR(GL_OBJECT_, RENDERBUFFER); + } + + { + py::class_ cls("gl_texture_info", py::no_init); + ADD_ATTR(GL_, TEXTURE_TARGET); + ADD_ATTR(GL_, MIPMAP_LEVEL); + } +#endif + + // }}} +} + + + + +// vim: foldmethod=marker -- GitLab