wrap_constants.cpp

// Wrap CL constants and errors
//
// Copyright (C) 2009 Andreas Kloeckner
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.


#define NO_IMPORT_ARRAY
#define PY_ARRAY_UNIQUE_SYMBOL pyopencl_ARRAY_API

#include "wrap_cl.hpp"


using namespace pyopencl;


namespace
{
  // {{{ 'fake' constant scopes
  class status_code { };
  class platform_info { };
  class device_type { };
  class device_info { };
  class device_topology_type_amd { };
  class device_fp_config { };
  class device_mem_cache_type { };
  class device_local_mem_type { };
  class device_exec_capabilities { };
  class device_svm_capabilities { };
  class command_queue_properties { };
  class context_info { };
  class gl_context_info { };
  class context_properties { };
  class command_queue_info { };
  class queue_properties { };
  class mem_flags { };
  class svm_mem_flags { };
  class channel_order { };
  class channel_type { };
  class mem_object_type { };
  class mem_info { };
  class image_info { };
  class pipe_info { };
  class pipe_properties { };
  class addressing_mode { };
  class filter_mode { };
  class sampler_info { };
  class sampler_properties { };
  class map_flags { };
  class program_info { };
  class program_build_info { };
  class program_binary_type { };
  class build_status { };
  class kernel_info { };
  class kernel_arg_info { };
  class kernel_arg_address_qualifier { };
  class kernel_arg_access_qualifier { };
  class kernel_arg_type_qualifier { };
  class kernel_work_group_info { };
  class kernel_sub_group_info { };
  class event_info { };
  class command_type { };
  class command_execution_status { };
  class profiling_info { };
  class buffer_create_type { };
  class mem_migration_flags { };

  class device_partition_property { };
  class device_affinity_domain { };
  class device_atomic_capabilities { };
  class device_device_enqueue_capabilities { };

  class version_bits { };
  class khronos_vendor_id { };

  class gl_object_type { };
  class gl_texture_info { };

  // }}}
}


void pyopencl_expose_constants(py::module_ &m)
{
  // {{{ exceptions
  {
#define DECLARE_EXC(NAME, BASE) \
  static py::exception<pyopencl::error> CL##NAME(m, #NAME, BASE);

    DECLARE_EXC(Error, PyExc_Exception);
    DECLARE_EXC(MemoryError, CLError.ptr());
    DECLARE_EXC(LogicError, CLError.ptr());
    DECLARE_EXC(RuntimeError, CLError.ptr());

    py::register_exception_translator(
        [](std::exception_ptr p)
        {
          try
          {
            if (p) std::rethrow_exception(p);
          }
          catch (pyopencl::error &err)
          {
            py::object err_obj = py::cast(err);
            if (err.code() == CL_MEM_OBJECT_ALLOCATION_FAILURE)
              PyErr_SetObject(CLMemoryError.ptr(), err_obj.ptr());
            else if (err.code() <= CL_INVALID_VALUE)
              PyErr_SetObject(CLLogicError.ptr(), err_obj.ptr());
            else if (err.code() > CL_INVALID_VALUE && err.code() < CL_SUCCESS)
              PyErr_SetObject(CLRuntimeError.ptr(), err_obj.ptr());
            else
              PyErr_SetObject(CLError.ptr(), err_obj.ptr());
          }
        });
  }
  // }}}

  // {{{ error record

  {
    typedef error cls;
    py::class_<error> (m, "_ErrorRecord")
      .def(py::init<const char *, cl_int, const char *>(),
          py::arg("routine"),
          py::arg("code"),
          py::arg("msg"))
      .DEF_SIMPLE_METHOD(routine)
      .DEF_SIMPLE_METHOD(code)
      .DEF_SIMPLE_METHOD(what)
      .DEF_SIMPLE_METHOD(is_out_of_memory)
      .def("_program", &cls::get_program)
      ;
  }

  // }}}

  // {{{ constants
#define ADD_ATTR(PREFIX, NAME) \
  cls.attr(#NAME) = CL_##PREFIX##NAME
#define ADD_ATTR_SUFFIX(PREFIX, NAME, SUFFIX) \
  cls.attr(#NAME) = CL_##PREFIX##NAME##SUFFIX

  {
    py::class_<status_code> cls(m, "status_code");

    ADD_ATTR(, SUCCESS);
    ADD_ATTR(, DEVICE_NOT_FOUND);
    ADD_ATTR(, DEVICE_NOT_AVAILABLE);
#if !(defined(CL_PLATFORM_NVIDIA) && CL_PLATFORM_NVIDIA == 0x3001)
    ADD_ATTR(, COMPILER_NOT_AVAILABLE);
#endif
    ADD_ATTR(, MEM_OBJECT_ALLOCATION_FAILURE);
    ADD_ATTR(, OUT_OF_RESOURCES);
    ADD_ATTR(, OUT_OF_HOST_MEMORY);
    ADD_ATTR(, PROFILING_INFO_NOT_AVAILABLE);
    ADD_ATTR(, MEM_COPY_OVERLAP);
    ADD_ATTR(, IMAGE_FORMAT_MISMATCH);
    ADD_ATTR(, IMAGE_FORMAT_NOT_SUPPORTED);
    ADD_ATTR(, BUILD_PROGRAM_FAILURE);
    ADD_ATTR(, MAP_FAILURE);

    ADD_ATTR(, INVALID_VALUE);
    ADD_ATTR(, INVALID_DEVICE_TYPE);
    ADD_ATTR(, INVALID_PLATFORM);
    ADD_ATTR(, INVALID_DEVICE);
    ADD_ATTR(, INVALID_CONTEXT);
    ADD_ATTR(, INVALID_QUEUE_PROPERTIES);
    ADD_ATTR(, INVALID_COMMAND_QUEUE);
    ADD_ATTR(, INVALID_HOST_PTR);
    ADD_ATTR(, INVALID_MEM_OBJECT);
    ADD_ATTR(, INVALID_IMAGE_FORMAT_DESCRIPTOR);
    ADD_ATTR(, INVALID_IMAGE_SIZE);
    ADD_ATTR(, INVALID_SAMPLER);
    ADD_ATTR(, INVALID_BINARY);
    ADD_ATTR(, INVALID_BUILD_OPTIONS);
    ADD_ATTR(, INVALID_PROGRAM);
    ADD_ATTR(, INVALID_PROGRAM_EXECUTABLE);
    ADD_ATTR(, INVALID_KERNEL_NAME);
    ADD_ATTR(, INVALID_KERNEL_DEFINITION);
    ADD_ATTR(, INVALID_KERNEL);
    ADD_ATTR(, INVALID_ARG_INDEX);