ceph/src/boost/boost/compute/exception/opencl_error.hpp

   1 //---------------------------------------------------------------------------//
   2 // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>
   3 //
   4 // Distributed under the Boost Software License, Version 1.0
   5 // See accompanying file LICENSE_1_0.txt or copy at
   6 // http://www.boost.org/LICENSE_1_0.txt
   7 //
   8 // See http://boostorg.github.com/compute for more information.
   9 //---------------------------------------------------------------------------//
  10
  11 #ifndef BOOST_COMPUTE_EXCEPTION_OPENCL_ERROR_HPP
  12 #define BOOST_COMPUTE_EXCEPTION_OPENCL_ERROR_HPP
  13
  14 #include <exception>
  15 #include <string>
  16 #include <sstream>
  17
  18 #include <boost/compute/cl.hpp>
  19
  20 namespace boost {
  21 namespace compute {
  22
  23 /// \class opencl_error
  24 /// \brief A run-time OpenCL error.
  25 ///
  26 /// The opencl_error class represents an error returned from an OpenCL
  27 /// function.
  28 ///
  29 /// \see context_error
  30 class opencl_error : public std::exception
  31 {
  32 public:
  33     /// Creates a new opencl_error exception object for \p error.
  34     explicit opencl_error(cl_int error) throw()
  35         : m_error(error),
  36           m_error_string(to_string(error))
  37     {
  38     }
  39
  40     /// Destroys the opencl_error object.
  41     ~opencl_error() throw()
  42     {
  43     }
  44
  45     /// Returns the numeric error code.
  46     cl_int error_code() const throw()
  47     {
  48         return m_error;
  49     }
  50
  51     /// Returns a string description of the error.
  52     std::string error_string() const throw()
  53     {
  54         return m_error_string;
  55     }
  56
  57     /// Returns a C-string description of the error.
  58     const char* what() const throw()
  59     {
  60         return m_error_string.c_str();
  61     }
  62
  63     /// Static function which converts the numeric OpenCL error code \p error
  64     /// to a human-readable string.
  65     ///
  66     /// For example:
  67     /// \code
  68     /// std::cout << opencl_error::to_string(CL_INVALID_KERNEL_ARGS) << std::endl;
  69     /// \endcode
  70     ///
  71     /// Will print "Invalid Kernel Arguments".
  72     ///
  73     /// If the error code is unknown (e.g. not a valid OpenCL error), a string
  74     /// containing "Unknown OpenCL Error" along with the error number will be
  75     /// returned.
  76     static std::string to_string(cl_int error)
  77     {
  78         switch(error){
  79         case CL_SUCCESS: return "Success";
  80         case CL_DEVICE_NOT_FOUND: return "Device Not Found";
  81         case CL_DEVICE_NOT_AVAILABLE: return "Device Not Available";
  82         case CL_COMPILER_NOT_AVAILABLE: return "Compiler Not Available";
  83         case CL_MEM_OBJECT_ALLOCATION_FAILURE: return "Memory Object Allocation Failure";
  84         case CL_OUT_OF_RESOURCES: return "Out of Resources";
  85         case CL_OUT_OF_HOST_MEMORY: return "Out of Host Memory";
  86         case CL_PROFILING_INFO_NOT_AVAILABLE: return "Profiling Information Not Available";
  87         case CL_MEM_COPY_OVERLAP: return "Memory Copy Overlap";
  88         case CL_IMAGE_FORMAT_MISMATCH: return "Image Format Mismatch";
  89         case CL_IMAGE_FORMAT_NOT_SUPPORTED: return "Image Format Not Supported";
  90         case CL_BUILD_PROGRAM_FAILURE: return "Build Program Failure";
  91         case CL_MAP_FAILURE: return "Map Failure";
  92         case CL_INVALID_VALUE: return "Invalid Value";
  93         case CL_INVALID_DEVICE_TYPE: return "Invalid Device Type";
  94         case CL_INVALID_PLATFORM: return "Invalid Platform";
  95         case CL_INVALID_DEVICE: return "Invalid Device";
  96         case CL_INVALID_CONTEXT: return "Invalid Context";
  97         case CL_INVALID_QUEUE_PROPERTIES: return "Invalid Queue Properties";
  98         case CL_INVALID_COMMAND_QUEUE: return "Invalid Command Queue";
  99         case CL_INVALID_HOST_PTR: return "Invalid Host Pointer";
 100         case CL_INVALID_MEM_OBJECT: return "Invalid Memory Object";
 101         case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: return "Invalid Image Format Descriptor";
 102         case CL_INVALID_IMAGE_SIZE: return "Invalid Image Size";
 103         case CL_INVALID_SAMPLER: return "Invalid Sampler";
 104         case CL_INVALID_BINARY: return "Invalid Binary";
 105         case CL_INVALID_BUILD_OPTIONS: return "Invalid Build Options";
 106         case CL_INVALID_PROGRAM: return "Invalid Program";
 107         case CL_INVALID_PROGRAM_EXECUTABLE: return "Invalid Program Executable";
 108         case CL_INVALID_KERNEL_NAME: return "Invalid Kernel Name";
 109         case CL_INVALID_KERNEL_DEFINITION: return "Invalid Kernel Definition";
 110         case CL_INVALID_KERNEL: return "Invalid Kernel";
 111         case CL_INVALID_ARG_INDEX: return "Invalid Argument Index";
 112         case CL_INVALID_ARG_VALUE: return "Invalid Argument Value";
 113         case CL_INVALID_ARG_SIZE: return "Invalid Argument Size";
 114         case CL_INVALID_KERNEL_ARGS: return "Invalid Kernel Arguments";
 115         case CL_INVALID_WORK_DIMENSION: return "Invalid Work Dimension";
 116         case CL_INVALID_WORK_GROUP_SIZE: return "Invalid Work Group Size";
 117         case CL_INVALID_WORK_ITEM_SIZE: return "Invalid Work Item Size";
 118         case CL_INVALID_GLOBAL_OFFSET: return "Invalid Global Offset";
 119         case CL_INVALID_EVENT_WAIT_LIST: return "Invalid Event Wait List";
 120         case CL_INVALID_EVENT: return "Invalid Event";
 121         case CL_INVALID_OPERATION: return "Invalid Operation";
 122         case CL_INVALID_GL_OBJECT: return "Invalid GL Object";
 123         case CL_INVALID_BUFFER_SIZE: return "Invalid Buffer Size";
 124         case CL_INVALID_MIP_LEVEL: return "Invalid MIP Level";
 125         case CL_INVALID_GLOBAL_WORK_SIZE: return "Invalid Global Work Size";
 126         #ifdef BOOST_COMPUTE_CL_VERSION_1_2
 127         case CL_COMPILE_PROGRAM_FAILURE: return "Compile Program Failure";
 128         case CL_LINKER_NOT_AVAILABLE: return "Linker Not Available";
 129         case CL_LINK_PROGRAM_FAILURE: return "Link Program Failure";
 130         case CL_DEVICE_PARTITION_FAILED: return "Device Partition Failed";
 131         case CL_KERNEL_ARG_INFO_NOT_AVAILABLE: return "Kernel Argument Info Not Available";
 132         case CL_INVALID_PROPERTY: return "Invalid Property";
 133         case CL_INVALID_IMAGE_DESCRIPTOR: return "Invalid Image Descriptor";
 134         case CL_INVALID_COMPILER_OPTIONS: return "Invalid Compiler Options";
 135         case CL_INVALID_LINKER_OPTIONS: return "Invalid Linker Options";
 136         case CL_INVALID_DEVICE_PARTITION_COUNT: return "Invalid Device Partition Count";
 137         #endif // BOOST_COMPUTE_CL_VERSION_1_2
 138         #ifdef BOOST_COMPUTE_CL_VERSION_2_0
 139         case CL_INVALID_PIPE_SIZE: return "Invalid Pipe Size";
 140         case CL_INVALID_DEVICE_QUEUE: return "Invalid Device Queue";
 141         #endif
 142         default: {
 143             std::stringstream s;
 144             s << "Unknown OpenCL Error (" << error << ")";
 145             return s.str();
 146         }
 147         }
 148     }
 149
 150 private:
 151     cl_int m_error;
 152     std::string m_error_string;
 153 };
 154
 155 } // end compute namespace
 156 } // end boost namespace
 157
 158 #endif // BOOST_COMPUTE_EXCEPTION_OPENCL_ERROR_HPP