ViennaCL - The Vienna Computing Library: viennacl/ocl/error.hpp Source File

ViennaCL - The Vienna Computing Library 1.7.1 Free open-source GPU-accelerated linear algebra and solver library. |

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
error.hpp
Go to the documentation of this file.
1 #ifndef VIENNACL_OCL_ERROR_HPP_
2 #define VIENNACL_OCL_ERROR_HPP_
3
4 /* =========================================================================
5 Copyright (c) 2010-2016, Institute for Microelectronics,
6 Institute for Analysis and Scientific Computing,
7 TU Wien.
8 Portions of this software are copyright by UChicago Argonne, LLC.
9
10 -----------------
11 ViennaCL - The Vienna Computing Library
12 -----------------
13
14 Project Head: Karl Rupp rupp@iue.tuwien.ac.at
15
16 (A list of authors and contributors can be found in the manual)
17
18 License: MIT (X11), see file LICENSE in the base directory
19 ============================================================================= */
20
25 //error levels:
26 //#define VIENNACL_DEBUG_ALL //print all of the following
27 //#define VIENNACL_DEBUG_KERNEL //debug any modifications on viennacl::ocl::kernel objects
28 //#define VIENNACL_DEBUG_COPY //print infos related to setting up/modifying memory objects
29 //#define VIENNACL_DEBUG_OPENCL //display debug info for the OpenCL layer (platform/context/queue creation,
30 //#define VIENNACL_DEBUG_DEVICE //Show device info upon allocation
31 //#define VIENNACL_DEBUG_CONTEXT //Debug queries to context
32 //#define VIENNACL_DEBUG_BUILD //Show debug info from OpenCL compiler
33
34
35 //backwards compatibility:
36 #ifdef VIENNACL_BUILD_INFO
37 #define VIENNACL_DEBUG_ALL
38 #endif
39
40
41 #ifdef __APPLE__
42 #include <OpenCL/cl.h>
43 #else
44 #include <CL/cl.h>
45 #endif
46
47 #include <string>
48 #include <iostream>
49 #include <exception>
50 #include <stdexcept>
51
52 #define VIENNACL_BUG_REPORT_STRING \
53 "\nIf you think that this is a bug in ViennaCL, please report it at viennacl-support@lists.sourceforge.net and supply at least the following information:\n"\
54 " * Operating System\n"\
55 " * Which OpenCL implementation (AMD, NVIDIA, etc.)\n"\
56 " * ViennaCL version\n"\
57 "Many thanks in advance!";\
58
59 namespace viennacl
60 {
61 namespace ocl
62 {
63 //
64 // Generic errors
65 //
66 class queue_not_found : public std::runtime_error
67 {
68 public:
69 queue_not_found(std::string const & what_arg) : std::runtime_error(what_arg) {}
70 };
71
72 class program_not_found : public std::runtime_error
73 {
74 public:
75 program_not_found(std::string const & what_arg) : std::runtime_error(what_arg) {}
76 };
77
78 class kernel_not_found : public std::runtime_error
79 {
80 public:
81 kernel_not_found(std::string const & what_arg) : std::runtime_error(what_arg) {}
82 };
83
84
85 //
86 // Wrapper for OpenCL exceptions:
87 //
88
93 class device_not_found : public std::exception
94 {
95 virtual const char* what() const throw()
96 {
97 return "ViennaCL: FATAL ERROR: CL_DEVICE_NOT_FOUND \n ViennaCL could not find a suitable device. Please check whether an OpenCL implementation is properly installed and a suitable device available."
98 VIENNACL_BUG_REPORT_STRING;
99 }
100 };
101
103 class device_not_available : public std::exception
104 {
105 virtual const char* what() const throw()
106 {
107 return "ViennaCL: FATAL ERROR: CL_DEVICE_NOT_AVAILABLE \n ViennaCL could not use the compute device because it is not available."
108 VIENNACL_BUG_REPORT_STRING;
109 }
110 };
111
113 class compiler_not_available : public std::exception
114 {
115 virtual const char* what() const throw()
116 {
117 return "ViennaCL: FATAL ERROR: CL_COMPILER_NOT_AVAILABLE \n Your OpenCL framework does not provide an OpenCL compiler. Unfortunately, ViennaCL cannot be used without such a compiler."
118 VIENNACL_BUG_REPORT_STRING;
119 }
120 };
121
123 class mem_object_allocation_failure : public std::exception
124 {
125 virtual const char* what() const throw()
126 {
127 return "ViennaCL: FATAL ERROR: CL_MEM_OBJECT_ALLOCATION_FAILURE \n ViennaCL could not allocate memory on the device. Most likely the device simply ran out of memory."
128 VIENNACL_BUG_REPORT_STRING;
129 }
130 };
131
133 class out_of_resources : public std::exception
134 {
135 virtual const char* what() const throw()
136 {
137 return "ViennaCL: FATAL ERROR: CL_OUT_OF_RESOURCES \n ViennaCL tried to launch a compute kernel, but the device does not provide enough resources. Try changing the global and local work item sizes."
138 VIENNACL_BUG_REPORT_STRING;
139 }
140 };
141
143 class out_of_host_memory : public std::exception
144 {
145 virtual const char* what() const throw()
146 {
147 return "ViennaCL: FATAL ERROR: CL_OUT_OF_HOST_MEMORY \n The host ran out of memory (usually CPU RAM). Please try again on smaller problems."
148 VIENNACL_BUG_REPORT_STRING;
149 }
150 };
151
153 class profiling_info_not_available : public std::exception
154 {
155 virtual const char* what() const throw()
156 {
157 return "ViennaCL: FATAL ERROR: CL_PROFILING_INFO_NOT_AVAILABLE."
158 VIENNACL_BUG_REPORT_STRING;
159 }
160 };
161
163 class mem_copy_overlap : public std::exception
164 {
165 virtual const char* what() const throw()
166 {
167 return "ViennaCL: FATAL ERROR: CL_MEM_COPY_OVERLAP."
168 VIENNACL_BUG_REPORT_STRING;
169 }
170 };
171
173 class image_format_mismatch : public std::exception
174 {
175 virtual const char* what() const throw()
176 {
177 return "ViennaCL: FATAL ERROR: CL_IMAGE_FORMAT_MISMATCH."
178 VIENNACL_BUG_REPORT_STRING;
179 }
180 };
181
183 class image_format_not_supported : public std::exception
184 {
185 virtual const char* what() const throw()
186 {
187 return "ViennaCL: FATAL ERROR: CL_IMAGE_FORMAT_NOT_SUPPORTED."
188 VIENNACL_BUG_REPORT_STRING;
189 }
190 };
191
193 class build_program_failure : public std::exception
194 {
195 virtual const char* what() const throw()
196 {
197 return "ViennaCL: FATAL ERROR: CL_BUILD_PROGRAM_FAILURE \n The OpenCL compiler encountered an error during the compilation of ViennaCL sources. This is most likely a bug in ViennaCL."
198 VIENNACL_BUG_REPORT_STRING;
199 }
200 };
201
203 class map_failure : public std::exception
204 {
205 virtual const char* what() const throw()
206 {
207 return "ViennaCL: FATAL ERROR: CL_MAP_FAILURE."
208 VIENNACL_BUG_REPORT_STRING;
209 }
210 };
211
213 class invalid_value : public std::exception
214 {
215 virtual const char* what() const throw()
216 {
217 return "ViennaCL: FATAL ERROR: CL_INVALID_VALUE."
218 VIENNACL_BUG_REPORT_STRING;
219 }
220 };
221
223 class invalid_device_type : public std::exception
224 {
225 virtual const char* what() const throw()
226 {
227 return "ViennaCL: FATAL ERROR: CL_INVALID_DEVICE_TYPE."
228 VIENNACL_BUG_REPORT_STRING;
229 }
230 };
231
233 class invalid_platform : public std::exception
234 {
235 virtual const char* what() const throw()
236 {
237 return "ViennaCL: FATAL ERROR: CL_INVALID_PLATFORM."
238 VIENNACL_BUG_REPORT_STRING;
239 }
240 };
241
243 class invalid_device : public std::exception
244 {
245 virtual const char* what() const throw()
246 {
247 return "ViennaCL: FATAL ERROR: CL_INVALID_DEVICE."
248 VIENNACL_BUG_REPORT_STRING;
249 }
250 };
251
253 class invalid_context : public std::exception
254 {
255 virtual const char* what() const throw()
256 {
257 return "ViennaCL: FATAL ERROR: CL_INVALID_CONTEXT."
258 VIENNACL_BUG_REPORT_STRING;
259 }
260 };
261
263 class invalid_queue_properties : public std::exception
264 {
265 virtual const char* what() const throw()
266 {
267 return "ViennaCL: FATAL ERROR: CL_INVALID_QUEUE_PROPERTIES."
268 VIENNACL_BUG_REPORT_STRING;
269 }
270 };
271
273 class invalid_command_queue : public std::exception
274 {
275 virtual const char* what() const throw()
276 {
277 return "ViennaCL: FATAL ERROR: CL_INVALID_COMMAND_QUEUE."
278 VIENNACL_BUG_REPORT_STRING;
279 }
280 };
281
283 class invalid_host_ptr : public std::exception
284 {
285 virtual const char* what() const throw()
286 {
287 return "ViennaCL: FATAL ERROR: CL_INVALID_HOST_PTR."
288 VIENNACL_BUG_REPORT_STRING;
289 }
290 };
291
293 class invalid_mem_object : public std::exception
294 {
295 virtual const char* what() const throw()
296 {
297 return "ViennaCL: FATAL ERROR: CL_INVALID_MEM_OBJECT."
298 VIENNACL_BUG_REPORT_STRING;
299 }
300 };
301
303 class invalid_image_format_descriptor : public std::exception
304 {
305 virtual const char* what() const throw()
306 {
307 return "ViennaCL: FATAL ERROR: CL_INVALID_IMAGE_FORMAT_DESCRIPTOR."
308 VIENNACL_BUG_REPORT_STRING;
309 }
310 };
311
313 class invalid_image_size : public std::exception
314 {
315 virtual const char* what() const throw()
316 {
317 return "ViennaCL: FATAL ERROR: CL_INVALID_IMAGE_SIZE."
318 VIENNACL_BUG_REPORT_STRING;
319 }
320 };
321
323 class invalid_sampler : public std::exception
324 {
325 virtual const char* what() const throw()
326 {
327 return "ViennaCL: FATAL ERROR: CL_INVALID_SAMPLER."
328 VIENNACL_BUG_REPORT_STRING;
329 }
330 };
331
333 class invalid_binary : public std::exception
334 {
335 virtual const char* what() const throw()
336 {
337 return "ViennaCL: FATAL ERROR: CL_INVALID_BINARY."
338 VIENNACL_BUG_REPORT_STRING;
339 }
340 };
341
343 class invalid_build_options : public std::exception
344 {
345 virtual const char* what() const throw()
346 {
347 return "ViennaCL: FATAL ERROR: CL_INVALID_BUILD_OPTIONS."
348 VIENNACL_BUG_REPORT_STRING;
349 }
350 };
351
353 class invalid_program : public std::exception
354 {
355 virtual const char* what() const throw()
356 {
357 return "ViennaCL: FATAL ERROR: CL_INVALID_PROGRAM."
358 VIENNACL_BUG_REPORT_STRING;
359 }
360 };
361
363 class invalid_program_executable : public std::exception
364 {
365 virtual const char* what() const throw()
366 {
367 return "ViennaCL: FATAL ERROR: CL_INVALID_PROGRAM_EXECUTABLE."
368 VIENNACL_BUG_REPORT_STRING;
369 }
370 };
371
373 class invalid_kernel_name : public std::exception
374 {
375 virtual const char* what() const throw()
376 {
377 return "ViennaCL: FATAL ERROR: CL_INVALID_KERNEL_NAME \n The supplied kernel name is invalid. If you have written your own OpenCL kernel, please check that the correct kernel name is used in the initalization of the kernel object."
378 VIENNACL_BUG_REPORT_STRING;
379 }
380 };
381
383 class invalid_kernel_definition : public std::exception
384 {
385 virtual const char* what() const throw()
386 {
387 return "ViennaCL: FATAL ERROR: CL_INVALID_KERNEL_DEFINITION."
388 VIENNACL_BUG_REPORT_STRING;
389 }
390 };
391
393 class invalid_kernel : public std::exception
394 {
395 virtual const char* what() const throw()
396 {
397 return "ViennaCL: FATAL ERROR: CL_INVALID_KERNEL \n The supplied kernel argument is invalid."
398 VIENNACL_BUG_REPORT_STRING;
399 }
400 };
401
403 class invalid_arg_index : public std::exception
404 {
405 virtual const char* what() const throw()
406 {
407 return "ViennaCL: FATAL ERROR: CL_INVALID_ARG_INDEX."
408 VIENNACL_BUG_REPORT_STRING;
409 }
410 };
411
413 class invalid_arg_value : public std::exception
414 {
415 virtual const char* what() const throw()
416 {
417 return "ViennaCL: FATAL ERROR: CL_INVALID_ARG_VALUE."
418 VIENNACL_BUG_REPORT_STRING;
419 }
420 };
421
423 class invalid_arg_size : public std::exception
424 {
425 virtual const char* what() const throw()
426 {
427 return "ViennaCL: FATAL ERROR: CL_INVALID_ARG_SIZE."
428 VIENNACL_BUG_REPORT_STRING;
429 }
430 };
431
433 class invalid_kernel_args : public std::exception
434 {
435 virtual const char* what() const throw()
436 {
437 return "ViennaCL: FATAL ERROR: CL_INVALID_KERNEL_ARGS \n The supplied kernel arguments do not fit the kernel parameter list. If you have written your own OpenCL kernel, please check that the correct kernel arguments are set in the appropriate order."
438 VIENNACL_BUG_REPORT_STRING;
439 }
440 };
441
443 class invalid_work_dimension : public std::exception
444 {
445 virtual const char* what() const throw()
446 {
447 return "ViennaCL: FATAL ERROR: CL_INVALID_WORK_DIMENSION"
448 VIENNACL_BUG_REPORT_STRING;
449 }
450 };
451
453 class invalid_work_group_size : public std::exception
454 {
455 virtual const char* what() const throw()
456 {
457 return "ViennaCL: FATAL ERROR: CL_INVALID_WORK_GROUP_SIZE \n The supplied work group size is invalid. If you have set this value manually, please reconsider your choice."
458 VIENNACL_BUG_REPORT_STRING;
459 }
460 };
461
463 class invalid_work_item_size : public std::exception
464 {
465 virtual const char* what() const throw()
466 {
467 return "ViennaCL: FATAL ERROR: CL_INVALID_WORK_ITEM_SIZE \n The work item size is invalid. If you have set this value manually, please reconsider your choice."
468 VIENNACL_BUG_REPORT_STRING;
469 }
470 };
471
473 class invalid_global_offset : public std::exception
474 {
475 virtual const char* what() const throw()
476 {
477 return "ViennaCL: FATAL ERROR: CL_INVALID_GLOBAL_OFFSET."
478 VIENNACL_BUG_REPORT_STRING;
479 }
480 };
481
483 class invalid_event_wait_list : public std::exception
484 {
485 virtual const char* what() const throw()
486 {
487 return "ViennaCL: FATAL ERROR: CL_INVALID_EVENT_WAIT_LIST."
488 VIENNACL_BUG_REPORT_STRING;
489 }
490 };
491
493 class invalid_event : public std::exception
494 {
495 virtual const char* what() const throw()
496 {
497 return "ViennaCL: FATAL ERROR: CL_INVALID_EVENT."
498 VIENNACL_BUG_REPORT_STRING;
499 }
500 };
501
503 class invalid_operation : public std::exception
504 {
505 virtual const char* what() const throw()
506 {
507 return "ViennaCL: FATAL ERROR: CL_INVALID_OPERATION."
508 VIENNACL_BUG_REPORT_STRING;
509 }
510 };
511
513 class invalid_gl_object : public std::exception
514 {
515 virtual const char* what() const throw()
516 {
517 return "ViennaCL: FATAL ERROR: CL_INVALID_GL_OBJECT."
518 VIENNACL_BUG_REPORT_STRING;
519 }
520 };
521
523 class invalid_buffer_size : public std::exception
524 {
525 virtual const char* what() const throw()
526 {
527 return "ViennaCL: FATAL ERROR: CL_INVALID_BUFFER_SIZE."
528 VIENNACL_BUG_REPORT_STRING;
529 }
530 };
531
533 class invalid_mip_level : public std::exception
534 {
535 virtual const char* what() const throw()
536 {
537 return "ViennaCL: FATAL ERROR: CL_INVALID_MIP_LEVEL."
538 VIENNACL_BUG_REPORT_STRING;
539 }
540 };
541
543 class invalid_global_work_size : public std::exception
544 {
545 virtual const char* what() const throw()
546 {
547 return "ViennaCL: FATAL ERROR: CL_INVALID_GLOBAL_WORK_SIZE."
548 VIENNACL_BUG_REPORT_STRING;
549 }
550 };
551
553 class invalid_property : public std::exception
554 {
555 virtual const char* what() const throw()
556 {
557 return "ViennaCL: FATAL ERROR: CL_INVALID_PROPERTY."
558 VIENNACL_BUG_REPORT_STRING;
559 }
560 };
561
563 class unknown_error : public std::exception
564 {
565 virtual const char* what() const throw()
566 {
567 return "ViennaCL: FATAL ERROR: ViennaCL encountered an unknown OpenCL error. Most likely your OpenCL SDK or driver is not installed properly. In some cases, this error is due to an invalid global work size or several kernel compilation errors."
568 VIENNACL_BUG_REPORT_STRING;
569 }
570 };
571
573 class double_precision_not_provided_error : public std::exception
574 {
575 virtual const char* what() const throw()
576 {
577 return "ViennaCL: FATAL ERROR: You requested to create a ViennaCL type using double precision. However, double precision is not supported by your device."
578 VIENNACL_BUG_REPORT_STRING;
579 }
580 };
581
582
588 template<typename T>
589 struct error_checker
590 {
591
593 static void raise_exception(cl_int err)
594 {
595 switch (err)
596 {
597 case CL_DEVICE_NOT_FOUND: throw device_not_found();
598 case CL_DEVICE_NOT_AVAILABLE: throw device_not_available();
599 case CL_COMPILER_NOT_AVAILABLE: throw compiler_not_available();
600 case CL_MEM_OBJECT_ALLOCATION_FAILURE: throw mem_object_allocation_failure();
601 case CL_OUT_OF_RESOURCES: throw out_of_resources();
602 case CL_OUT_OF_HOST_MEMORY: throw out_of_host_memory();
603 case CL_PROFILING_INFO_NOT_AVAILABLE: throw profiling_info_not_available();
604 case CL_MEM_COPY_OVERLAP: throw mem_copy_overlap();
605 case CL_IMAGE_FORMAT_MISMATCH: throw image_format_mismatch();
606 case CL_IMAGE_FORMAT_NOT_SUPPORTED: throw image_format_not_supported();
607 case CL_BUILD_PROGRAM_FAILURE: throw build_program_failure();
608 case CL_MAP_FAILURE: throw map_failure();
609
610 case CL_INVALID_VALUE: throw invalid_value();
611 case CL_INVALID_DEVICE_TYPE: throw invalid_device_type();
612 case CL_INVALID_PLATFORM: throw invalid_platform();
613 case CL_INVALID_DEVICE: throw invalid_device();
614 case CL_INVALID_CONTEXT: throw invalid_context();
615 case CL_INVALID_QUEUE_PROPERTIES: throw invalid_queue_properties();
616 case CL_INVALID_COMMAND_QUEUE: throw invalid_command_queue();
617 case CL_INVALID_HOST_PTR: throw invalid_host_ptr();
618 case CL_INVALID_MEM_OBJECT: throw invalid_mem_object();
619 case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: throw invalid_image_format_descriptor();
620 case CL_INVALID_IMAGE_SIZE: throw invalid_image_size();
621 case CL_INVALID_SAMPLER: throw invalid_sampler();
622 case CL_INVALID_BINARY: throw invalid_binary();
623 case CL_INVALID_BUILD_OPTIONS: throw invalid_build_options();
624 case CL_INVALID_PROGRAM: throw invalid_program();
625 case CL_INVALID_PROGRAM_EXECUTABLE: throw invalid_program_executable();
626 case CL_INVALID_KERNEL_NAME: throw invalid_kernel_name();
627 case CL_INVALID_KERNEL_DEFINITION: throw invalid_kernel_definition();
628 case CL_INVALID_KERNEL: throw invalid_kernel();
629 case CL_INVALID_ARG_INDEX: throw invalid_arg_index();
630 case CL_INVALID_ARG_VALUE: throw invalid_arg_value();
631 case CL_INVALID_ARG_SIZE: throw invalid_arg_size();
632 case CL_INVALID_KERNEL_ARGS: throw invalid_kernel_args();
633 case CL_INVALID_WORK_DIMENSION: throw invalid_work_dimension();
634 case CL_INVALID_WORK_GROUP_SIZE: throw invalid_work_group_size();
635 case CL_INVALID_WORK_ITEM_SIZE: throw invalid_work_item_size();
636 case CL_INVALID_GLOBAL_OFFSET: throw invalid_global_offset();
637 case CL_INVALID_EVENT_WAIT_LIST: throw invalid_event_wait_list();
638 case CL_INVALID_EVENT: throw invalid_event();
639 case CL_INVALID_OPERATION: throw invalid_operation();
640 case CL_INVALID_GL_OBJECT: throw invalid_gl_object();
641 case CL_INVALID_BUFFER_SIZE: throw invalid_buffer_size();
642 case CL_INVALID_MIP_LEVEL: throw invalid_mip_level();
643 case CL_INVALID_GLOBAL_WORK_SIZE: throw invalid_global_work_size();
644 #ifdef CL_INVALID_PROPERTY
645 case CL_INVALID_PROPERTY: throw invalid_property();
646 #endif
647 // return "CL_INVALID_GLOBAL_WORK_SIZE";
648
649 default: throw unknown_error();
650 }
651
652 } //getErrorString
653
658 static void checkError(cl_int err,
659
660 #ifdef VIENNACL_DEBUG_ALL
661 const char * file,
662 const char * func,
663 int line)
664 #else
665 const char *,
666 const char *,
667 int)
668 #endif
669 {
670 if (err != CL_SUCCESS)
671 {
672 #ifdef VIENNACL_DEBUG_ALL
673 std::cerr << "ViennaCL: Error " << err << " in function " << func << " ( "<< file << ":" << line << " ) " << std::endl;
674 #endif
675 raise_exception(err);
676 }
677 } //checkError()
678
679 }; //struct
680
681 #define VIENNACL_ERR_CHECK(err) viennacl::ocl::error_checker<void>::checkError(err, __FILE__, __FUNCTION__, __LINE__);
682
683 } //namespace ocl
684 } //namespace viennacl
685
686 #endif
687
viennacl::ocl::invalid_device_type
Exception thrown if an invalid device type is specified.
Definition: error.hpp:223
viennacl::ocl::queue_not_found::queue_not_found
queue_not_found(std::string const &what_arg)
Definition: error.hpp:69
viennacl::ocl::error_checker
An error reporting class. Template argument is used to avoid problems with external linkage...
Definition: error.hpp:589
viennacl::ocl::queue_not_found
Definition: error.hpp:66
viennacl::ocl::invalid_image_size
Exception thrown if the image size provided is invalid (e.g. zero).
Definition: error.hpp:313
viennacl::ocl::compiler_not_available
Exception thrown if the OpenCL just-in-time compiler is not available.
Definition: error.hpp:113
viennacl::ocl::program_not_found
Definition: error.hpp:72
viennacl::ocl::mem_object_allocation_failure
Exception thrown if a memory object cannot be allocated. Usually the requested memory buffer is simpl...
Definition: error.hpp:123
viennacl::ocl::invalid_work_group_size
Exception thrown if the number of work groups is invalid (usually this means that more than 256/512/7...
Definition: error.hpp:453
viennacl::ocl::invalid_host_ptr
Exception thrown if the provided pointer to host memory is invalid.
Definition: error.hpp:283
viennacl::ocl::invalid_build_options
Exception thrown if invalid build options are passed to the OpenCL just-in-time compiler.
Definition: error.hpp:343
viennacl::ocl::mem_copy_overlap
Exception thrown if the source buffer overlaps the destination buffer when copying from device memory...
Definition: error.hpp:163
viennacl::ocl::device_not_available
Exception thrown if the selected compute device is not available (maybe locked by another process)...
Definition: error.hpp:103
viennacl::ocl::invalid_arg_value
Exception thrown if the kernel argument provided has an invalid value.
Definition: error.hpp:413
viennacl::ocl::out_of_host_memory
Exception thrown if the host cannot provide enough memory for the datastructures in the OpenCL backen...
Definition: error.hpp:143
VIENNACL_BUG_REPORT_STRING
#define VIENNACL_BUG_REPORT_STRING
Definition: error.hpp:52
viennacl::ocl::invalid_gl_object
Exception thrown if the provided OpenGL (not OpenCL) object is invalid.
Definition: error.hpp:513
viennacl::ocl::invalid_arg_index
Exception thrown if the kernel argument index is invalid, e.g. an arg index larger than the number of...
Definition: error.hpp:403
viennacl::ocl::invalid_platform
Exception thrown if an invalid OpenCL platform is provided to an OpenCL function. ...
Definition: error.hpp:233
viennacl::ocl::invalid_program_executable
Exception thrown if there is no built program exectuable available for the device.
Definition: error.hpp:363
viennacl::ocl::invalid_mip_level
Exception thrown if the provided miplevel is greater than zero, but the OpenGL implementation does no...
Definition: error.hpp:533
viennacl::ocl::invalid_kernel_definition
Exception thrown if the kernel definition (number of arguments, argument types, etc.) is not the same for all devices for which the program has been built.
Definition: error.hpp:383
viennacl::ocl::image_format_mismatch
Exception thrown if there is a mismatch in image formats for the operands.
Definition: error.hpp:173
viennacl::ocl::invalid_program
Exception thrown if an OpenCL program object handle is invalid (e.g. not initialized).
Definition: error.hpp:353
viennacl::ocl::invalid_operation
Exception thrown if interoperability of OpenCL with other frameworks collide.
Definition: error.hpp:503
viennacl::ocl::program_not_found::program_not_found
program_not_found(std::string const &what_arg)
Definition: error.hpp:75
viennacl::ocl::out_of_resources
Exception thrown if the compute device is out of resources (either global memory, registers...
Definition: error.hpp:133
viennacl::ocl::double_precision_not_provided_error
Exception thrown if the user wants to use double precision arithmetics, but the device does not suppo...
Definition: error.hpp:573
viennacl::ocl::invalid_device
Exception thrown if an invalid OpenCL device is provided to an OpenCL function.
Definition: error.hpp:243
viennacl::ocl::invalid_buffer_size
Exception thrown if the provided buffer size is invalid (e.g. zero)
Definition: error.hpp:523
viennacl::ocl::error_checker::checkError
static void checkError(cl_int err, const char *, const char *, int)
Checks whether an OpenCL error has occured.
Definition: error.hpp:658
viennacl::ocl::invalid_event
Exception thrown if the provided event object (of type cl_event) is invalid.
Definition: error.hpp:493
viennacl::ocl::invalid_arg_size
Exception thrown if the arguments to an OpenCL kernel have an invalid size e.g. not sizeof(cl_mem))...
Definition: error.hpp:423
viennacl::ocl::invalid_kernel_args
Exception thrown if the kernel arguments are invalid and/or do not fit the kernel parameter list...
Definition: error.hpp:433
viennacl::ocl::invalid_mem_object
Exception thrown if an invalid OpenCL memory object (of type cl_mem) is passed to an OpenCL funciton...
Definition: error.hpp:293
viennacl::ocl::invalid_context
Exception thrown if an invalid OpenCL context is provided to an OpenCL function.
Definition: error.hpp:253
viennacl::ocl::kernel_not_found::kernel_not_found
kernel_not_found(std::string const &what_arg)
Definition: error.hpp:81
viennacl::ocl::invalid_global_work_size
Exception thrown if the total number of work items is invalid (for example, not divisible by the numb...
Definition: error.hpp:543
viennacl::ocl::invalid_work_dimension
Exception thrown if the work dimension is invalid (usually this means that the work dimension was set...
Definition: error.hpp:443
viennacl::ocl::invalid_kernel_name
Exception thrown if the provided kernel name is invalid (e.g. not part of the program provided)...
Definition: error.hpp:373
viennacl::ocl::error_checker::raise_exception
static void raise_exception(cl_int err)
Trows exceptions that reflect OpenCL error codes.
Definition: error.hpp:593
viennacl::ocl::invalid_command_queue
Exception thrown if an invalid OpenCL command queue is provided to an OpenCL function.
Definition: error.hpp:273
viennacl::ocl::invalid_kernel
Exception thrown if the provided kernel object (of type cl_kernel) is invalid (e.g. not initialized, from different context, or corrupted).
Definition: error.hpp:393
viennacl::ocl::device_not_found
Exception thrown in the case that a requested compute device was not found.
Definition: error.hpp:93
viennacl::ocl::invalid_global_offset
Exception thrown if the provided offset for get_global_id() in OpenCL kernels is invalid.
Definition: error.hpp:473
viennacl::ocl::invalid_property
Exception thrown if an invalid property is provided to a function (vague value).
Definition: error.hpp:553
viennacl::ocl::profiling_info_not_available
Exception thrown if the OpenCL context does not have CL_QUEUE_PROFILING_ENABLE set, if the execution is not complete, or the event object is a user event object.
Definition: error.hpp:153
viennacl::ocl::invalid_event_wait_list
Exception thrown if the provided event wait list is invalid.
Definition: error.hpp:483
viennacl::ocl::invalid_image_format_descriptor
Exception thrown if an invalid image format descriptor is provided.
Definition: error.hpp:303
viennacl::ocl::build_program_failure
Exception thrown if the OpenCL program cannot be built, usually due to a syntax error in the OpenCL c...
Definition: error.hpp:193
viennacl::ocl::kernel_not_found
Definition: error.hpp:78
viennacl::ocl::invalid_work_item_size
Exception thrown if the number of work items per work group invalid (usually this means that more tha...
Definition: error.hpp:463
viennacl::ocl::image_format_not_supported
Exception thrown if the requested image format is not supported.
Definition: error.hpp:183
viennacl::ocl::invalid_binary
Exception thrown if the OpenCL binary (generated from the jit-compiler or loaded from some other loca...
Definition: error.hpp:333
viennacl::ocl::invalid_sampler
Exception thrown if an invalid sampler is provided for an image.
Definition: error.hpp:323
viennacl::ocl::map_failure
Exception thrown if the mapping of device memory to the host memory space failed. ...
Definition: error.hpp:203
viennacl::ocl::unknown_error
Exception thrown if the returned error cannot be resolved to some defined error constant. Might result from invalid sources, invalid memory operations, etc.
Definition: error.hpp:563
viennacl::ocl::invalid_queue_properties
Exception thrown if invalid OpenCL command queue properties are provided when creating a command queu...
Definition: error.hpp:263
viennacl::ocl::invalid_value
Exception thrown is an invalid value is provided to an OpenCL function.
Definition: error.hpp:213