vSMC
vSMC: Scalable Monte Carlo
cl_error.hpp
Go to the documentation of this file.
1 //============================================================================
2 // vSMC/include/vsmc/opencl/cl_error.hpp
3 //----------------------------------------------------------------------------
4 // vSMC: Scalable Monte Carlo
5 //----------------------------------------------------------------------------
6 // Copyright (c) 2013,2014, Yan Zhou
7 // All rights reserved.
8 //
9 // Redistribution and use in source and binary forms, with or without
10 // modification, are permitted provided that the following conditions are met:
11 //
12 // Redistributions of source code must retain the above copyright notice,
13 // this list of conditions and the following disclaimer.
14 //
15 // Redistributions in binary form must reproduce the above copyright notice,
16 // this list of conditions and the following disclaimer in the documentation
17 // and/or other materials provided with the distribution.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
20 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
23 // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 // POSSIBILITY OF SUCH DAMAGE.
30 //============================================================================
31 
32 #ifndef VSMC_OPENCL_CL_ERROR_HPP
33 #define VSMC_OPENCL_CL_ERROR_HPP
34 
35 #include <vsmc/internal/common.hpp>
36 #include <vsmc/opencl/internal/cl_wrapper.hpp>
37 
38 #define VSMC_DEFINE_OPENCL_CL_ERROR_ERR(STATUS) case STATUS : return #STATUS
39 
40 namespace vsmc {
41 
42 namespace internal {
43 
44 inline std::string cl_error_str (cl_int status)
45 {
46  switch (status) {
47  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_SUCCESS);
48  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_DEVICE_NOT_FOUND);
49  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_DEVICE_NOT_AVAILABLE);
50  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_COMPILER_NOT_AVAILABLE);
51  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_MEM_OBJECT_ALLOCATION_FAILURE);
52  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_OUT_OF_RESOURCES);
53  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_OUT_OF_HOST_MEMORY);
54  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_PROFILING_INFO_NOT_AVAILABLE);
55  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_MEM_COPY_OVERLAP);
56  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_IMAGE_FORMAT_MISMATCH);
57  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_IMAGE_FORMAT_NOT_SUPPORTED);
58  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_BUILD_PROGRAM_FAILURE);
59  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_MAP_FAILURE);
60 #if VSMC_OPENCL_VERSION >= 110
61  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_MISALIGNED_SUB_BUFFER_OFFSET);
62  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(
63  CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST);
64 #endif
65 #if VSMC_OPENCL_VERSION >= 120
66  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_COMPILE_PROGRAM_FAILURE);
67  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_LINKER_NOT_AVAILABLE);
68  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_LINK_PROGRAM_FAILURE);
69  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_DEVICE_PARTITION_FAILED);
70  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_KERNEL_ARG_INFO_NOT_AVAILABLE);
71 #endif
72 #if VSMC_OPENCL_VERSION >= 200
73  // No new error code in OpenCL 2.0
74 #endif
75 
76  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_VALUE);
77  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_DEVICE_TYPE);
78  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_PLATFORM);
79  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_DEVICE);
80  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_CONTEXT);
81  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_QUEUE_PROPERTIES);
82  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_COMMAND_QUEUE);
83  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_HOST_PTR);
84  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_MEM_OBJECT);
85  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR);
86  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_IMAGE_SIZE);
87  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_SAMPLER);
88  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_BINARY);
89  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_BUILD_OPTIONS);
90  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_PROGRAM);
91  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_PROGRAM_EXECUTABLE);
92  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_KERNEL_NAME);
93  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_KERNEL_DEFINITION);
94  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_KERNEL);
95  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_ARG_INDEX);
96  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_ARG_VALUE);
97  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_ARG_SIZE);
98  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_KERNEL_ARGS);
99  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_WORK_DIMENSION);
100  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_WORK_GROUP_SIZE);
101  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_WORK_ITEM_SIZE);
102  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_GLOBAL_OFFSET);
103  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_EVENT_WAIT_LIST);
104  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_EVENT);
105  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_OPERATION);
106  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_GL_OBJECT);
107  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_BUFFER_SIZE);
108  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_MIP_LEVEL);
109  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_GLOBAL_WORK_SIZE);
110 #if VSMC_OPENCL_VERSION >= 110
111  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_PROPERTY);
112 #endif
113 #if VSMC_OPENCL_VERSION >= 120
114  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_IMAGE_DESCRIPTOR);
115  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_COMPILER_OPTIONS);
116  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_LINKER_OPTIONS);
117  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_DEVICE_PARTITION_COUNT);
118 #endif
119 #if VSMC_OPENCL_VERSION >= 200
120  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_PIPE_SIZE);
121  VSMC_DEFINE_OPENCL_CL_ERROR_ERR(CL_INVALID_DEVICE_QUEUE);
122 #endif
123  default : return "UNKNOWN";
124  }
125 }
126 
127 } // namespace vsmc::internal
128 
137 class CLError : public std::runtime_error
138 {
139  public:
140 
141  CLError () :
142  std::runtime_error(internal::cl_error_str(CL_SUCCESS)),
143  status_(CL_SUCCESS) {}
144 
145  explicit CLError (cl_int status) :
146  std::runtime_error(internal::cl_error_str(status)),
147  status_(status) {}
148 
149  explicit CLError (const ::cl::Error &err) :
150  std::runtime_error(std::string(err.what()) + ":" +
151  internal::cl_error_str(err.err())), status_(err.err()) {}
152 
153  CLError (cl_int status, const char * msg) :
154  std::runtime_error(std::string(msg) + ":" +
155  internal::cl_error_str(status)), status_(status) {}
156 
157  CLError (cl_int status, const std::string &msg) :
158  std::runtime_error(msg + ":" +
159  internal::cl_error_str(status)), status_(status) {}
160 
161  cl_int err () const {return status_;}
162 
163  cl_int status () const {return status_;}
164 
165  private:
166 
167  cl_int status_;
168 }; // class CLError
169 
170 } // namespace vsmc
171 
172 #endif // VSMC_OPENCL_CL_ERROR_HPP
vsmc
Definition: adapter.hpp:37
vsmc::CLError
OpenCL exception.
Definition: cl_error.hpp:137
vsmc::CLError::CLError
CLError(cl_int status, const char *msg)
Definition: cl_error.hpp:153
std
STL namespace.
VSMC_DEFINE_OPENCL_CL_ERROR_ERR
#define VSMC_DEFINE_OPENCL_CL_ERROR_ERR(STATUS)
Definition: cl_error.hpp:38
vsmc::CLError::CLError
CLError(cl_int status, const std::string &msg)
Definition: cl_error.hpp:157
cl_wrapper.hpp
vsmc::CLError::CLError
CLError(cl_int status)
Definition: cl_error.hpp:145
vsmc::internal::cl_error_str
std::string cl_error_str(cl_int status)
Definition: cl_error.hpp:44
vsmc::CLError::err
cl_int err() const
Definition: cl_error.hpp:161
vsmc::CLError::status
cl_int status() const
Definition: cl_error.hpp:163
vsmc::CLError::CLError
CLError(const ::cl::Error &err)
Definition: cl_error.hpp:149
Generated by   doxygen 1.8.9.1