ViennaCL - The Vienna Computing Library  1.5.2
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-2014, 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 PDF 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 
51 #define VIENNACL_BUG_REPORT_STRING \
52  "\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"\
53  " * Operating System\n"\
54  " * Which OpenCL implementation (AMD, NVIDIA, etc.)\n"\
55  " * ViennaCL version\n"\
56  "Many thanks in advance!";\
57 
58 namespace viennacl
59 {
60  namespace ocl
61  {
62  //Wrapper for OpenCL exceptions:
63 
68  class device_not_found : public std::exception
69  {
70  virtual const char* what() const throw()
71  {
72  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."
74  }
75  };
76 
78  class device_not_available : public std::exception
79  {
80  virtual const char* what() const throw()
81  {
82  return "ViennaCL: FATAL ERROR: CL_DEVICE_NOT_AVAILABLE \n ViennaCL could not use the compute device because it is not available."
84  }
85  };
86 
88  class compiler_not_available : public std::exception
89  {
90  virtual const char* what() const throw()
91  {
92  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."
94  }
95  };
96 
98  class mem_object_allocation_failure : public std::exception
99  {
100  virtual const char* what() const throw()
101  {
102  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."
104  }
105  };
106 
108  class out_of_resources : public std::exception
109  {
110  virtual const char* what() const throw()
111  {
112  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."
114  }
115  };
116 
118  class out_of_host_memory : public std::exception
119  {
120  virtual const char* what() const throw()
121  {
122  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."
124  }
125  };
126 
128  class profiling_info_not_available : public std::exception
129  {
130  virtual const char* what() const throw()
131  {
132  return "ViennaCL: FATAL ERROR: CL_PROFILING_INFO_NOT_AVAILABLE."
134  }
135  };
136 
138  class mem_copy_overlap : public std::exception
139  {
140  virtual const char* what() const throw()
141  {
142  return "ViennaCL: FATAL ERROR: CL_MEM_COPY_OVERLAP."
144  }
145  };
146 
148  class image_format_mismatch : public std::exception
149  {
150  virtual const char* what() const throw()
151  {
152  return "ViennaCL: FATAL ERROR: CL_IMAGE_FORMAT_MISMATCH."
154  }
155  };
156 
158  class image_format_not_supported : public std::exception
159  {
160  virtual const char* what() const throw()
161  {
162  return "ViennaCL: FATAL ERROR: CL_IMAGE_FORMAT_NOT_SUPPORTED."
164  }
165  };
166 
168  class build_program_failure : public std::exception
169  {
170  virtual const char* what() const throw()
171  {
172  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."
174  }
175  };
176 
178  class map_failure : public std::exception
179  {
180  virtual const char* what() const throw()
181  {
182  return "ViennaCL: FATAL ERROR: CL_MAP_FAILURE."
184  }
185  };
186 
188  class invalid_value : public std::exception
189  {
190  virtual const char* what() const throw()
191  {
192  return "ViennaCL: FATAL ERROR: CL_INVALID_VALUE."
194  }
195  };
196 
198  class invalid_device_type : public std::exception
199  {
200  virtual const char* what() const throw()
201  {
202  return "ViennaCL: FATAL ERROR: CL_INVALID_DEVICE_TYPE."
204  }
205  };
206 
208  class invalid_platform : public std::exception
209  {
210  virtual const char* what() const throw()
211  {
212  return "ViennaCL: FATAL ERROR: CL_INVALID_PLATFORM."
214  }
215  };
216 
218  class invalid_device : public std::exception
219  {
220  virtual const char* what() const throw()
221  {
222  return "ViennaCL: FATAL ERROR: CL_INVALID_DEVICE."
224  }
225  };
226 
228  class invalid_context : public std::exception
229  {
230  virtual const char* what() const throw()
231  {
232  return "ViennaCL: FATAL ERROR: CL_INVALID_CONTEXT."
234  }
235  };
236 
238  class invalid_queue_properties : public std::exception
239  {
240  virtual const char* what() const throw()
241  {
242  return "ViennaCL: FATAL ERROR: CL_INVALID_QUEUE_PROPERTIES."
244  }
245  };
246 
248  class invalid_command_queue : public std::exception
249  {
250  virtual const char* what() const throw()
251  {
252  return "ViennaCL: FATAL ERROR: CL_INVALID_COMMAND_QUEUE."
254  }
255  };
256 
258  class invalid_host_ptr : public std::exception
259  {
260  virtual const char* what() const throw()
261  {
262  return "ViennaCL: FATAL ERROR: CL_INVALID_HOST_PTR."
264  }
265  };
266 
268  class invalid_mem_object : public std::exception
269  {
270  virtual const char* what() const throw()
271  {
272  return "ViennaCL: FATAL ERROR: CL_INVALID_MEM_OBJECT."
274  }
275  };
276 
278  class invalid_image_format_descriptor : public std::exception
279  {
280  virtual const char* what() const throw()
281  {
282  return "ViennaCL: FATAL ERROR: CL_INVALID_IMAGE_FORMAT_DESCRIPTOR."
284  }
285  };
286 
288  class invalid_image_size : public std::exception
289  {
290  virtual const char* what() const throw()
291  {
292  return "ViennaCL: FATAL ERROR: CL_INVALID_IMAGE_SIZE."
294  }
295  };
296 
298  class invalid_sampler : public std::exception
299  {
300  virtual const char* what() const throw()
301  {
302  return "ViennaCL: FATAL ERROR: CL_INVALID_SAMPLER."
304  }
305  };
306 
308  class invalid_binary : public std::exception
309  {
310  virtual const char* what() const throw()
311  {
312  return "ViennaCL: FATAL ERROR: CL_INVALID_BINARY."
314  }
315  };
316 
318  class invalid_build_options : public std::exception
319  {
320  virtual const char* what() const throw()
321  {
322  return "ViennaCL: FATAL ERROR: CL_INVALID_BUILD_OPTIONS."
324  }
325  };
326 
328  class invalid_program : public std::exception
329  {
330  virtual const char* what() const throw()
331  {
332  return "ViennaCL: FATAL ERROR: CL_INVALID_PROGRAM."
334  }
335  };
336 
338  class invalid_program_executable : public std::exception
339  {
340  virtual const char* what() const throw()
341  {
342  return "ViennaCL: FATAL ERROR: CL_INVALID_PROGRAM_EXECUTABLE."
344  }
345  };
346 
348  class invalid_kernel_name : public std::exception
349  {
350  virtual const char* what() const throw()
351  {
352  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."
354  }
355  };
356 
358  class invalid_kernel_definition : public std::exception
359  {
360  virtual const char* what() const throw()
361  {
362  return "ViennaCL: FATAL ERROR: CL_INVALID_KERNEL_DEFINITION."
364  }
365  };
366 
368  class invalid_kernel : public std::exception
369  {
370  virtual const char* what() const throw()
371  {
372  return "ViennaCL: FATAL ERROR: CL_INVALID_KERNEL \n The supplied kernel argument is invalid."
374  }
375  };
376 
378  class invalid_arg_index : public std::exception
379  {
380  virtual const char* what() const throw()
381  {
382  return "ViennaCL: FATAL ERROR: CL_INVALID_ARG_INDEX."
384  }
385  };
386 
388  class invalid_arg_value : public std::exception
389  {
390  virtual const char* what() const throw()
391  {
392  return "ViennaCL: FATAL ERROR: CL_INVALID_ARG_VALUE."
394  }
395  };
396 
398  class invalid_arg_size : public std::exception
399  {
400  virtual const char* what() const throw()
401  {
402  return "ViennaCL: FATAL ERROR: CL_INVALID_ARG_SIZE."
404  }
405  };
406 
408  class invalid_kernel_args : public std::exception
409  {
410  virtual const char* what() const throw()
411  {
412  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."
414  }
415  };
416 
418  class invalid_work_dimension : public std::exception
419  {
420  virtual const char* what() const throw()
421  {
422  return "ViennaCL: FATAL ERROR: CL_INVALID_WORK_DIMENSION"
424  }
425  };
426 
428  class invalid_work_group_size : public std::exception
429  {
430  virtual const char* what() const throw()
431  {
432  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."
434  }
435  };
436 
438  class invalid_work_item_size : public std::exception
439  {
440  virtual const char* what() const throw()
441  {
442  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."
444  }
445  };
446 
448  class invalid_global_offset : public std::exception
449  {
450  virtual const char* what() const throw()
451  {
452  return "ViennaCL: FATAL ERROR: CL_INVALID_GLOBAL_OFFSET."
454  }
455  };
456 
458  class invalid_event_wait_list : public std::exception
459  {
460  virtual const char* what() const throw()
461  {
462  return "ViennaCL: FATAL ERROR: CL_INVALID_EVENT_WAIT_LIST."
464  }
465  };
466 
468  class invalid_event : public std::exception
469  {
470  virtual const char* what() const throw()
471  {
472  return "ViennaCL: FATAL ERROR: CL_INVALID_EVENT."
474  }
475  };
476 
478  class invalid_operation : public std::exception
479  {
480  virtual const char* what() const throw()
481  {
482  return "ViennaCL: FATAL ERROR: CL_INVALID_OPERATION."
484  }
485  };
486 
488  class invalid_gl_object : public std::exception
489  {
490  virtual const char* what() const throw()
491  {
492  return "ViennaCL: FATAL ERROR: CL_INVALID_GL_OBJECT."
494  }
495  };
496 
498  class invalid_buffer_size : public std::exception
499  {
500  virtual const char* what() const throw()
501  {
502  return "ViennaCL: FATAL ERROR: CL_INVALID_BUFFER_SIZE."
504  }
505  };
506 
508  class invalid_mip_level : public std::exception
509  {
510  virtual const char* what() const throw()
511  {
512  return "ViennaCL: FATAL ERROR: CL_INVALID_MIP_LEVEL."
514  }
515  };
516 
518  class invalid_global_work_size : public std::exception
519  {
520  virtual const char* what() const throw()
521  {
522  return "ViennaCL: FATAL ERROR: CL_INVALID_GLOBAL_WORK_SIZE."
524  }
525  };
526 
528  class invalid_property : public std::exception
529  {
530  virtual const char* what() const throw()
531  {
532  return "ViennaCL: FATAL ERROR: CL_INVALID_PROPERTY."
534  }
535  };
536 
538  class unknown_error : public std::exception
539  {
540  virtual const char* what() const throw()
541  {
542  return "ViennaCL: FATAL ERROR: ViennaCL encountered an unknown OpenCL error. In some cases, this might be due to an invalid global work size, but it can also be due to several compilation errors."
544  }
545  };
546 
548  class double_precision_not_provided_error : public std::exception
549  {
550  virtual const char* what() const throw()
551  {
552  return "ViennaCL: FATAL ERROR: You requested to create a ViennaCL type using double precision. However, double precision is not supported by your device."
554  }
555  };
556 
557 
563  template <typename T>
565  {
566 
568  static void raise_exception(cl_int err)
569  {
570  switch (err)
571  {
572  case CL_DEVICE_NOT_FOUND: throw device_not_found();
573  case CL_DEVICE_NOT_AVAILABLE: throw device_not_available();
574  case CL_COMPILER_NOT_AVAILABLE: throw compiler_not_available();
575  case CL_MEM_OBJECT_ALLOCATION_FAILURE: throw mem_object_allocation_failure();
576  case CL_OUT_OF_RESOURCES: throw out_of_resources();
577  case CL_OUT_OF_HOST_MEMORY: throw out_of_host_memory();
578  case CL_PROFILING_INFO_NOT_AVAILABLE: throw profiling_info_not_available();
579  case CL_MEM_COPY_OVERLAP: throw mem_copy_overlap();
580  case CL_IMAGE_FORMAT_MISMATCH: throw image_format_mismatch();
581  case CL_IMAGE_FORMAT_NOT_SUPPORTED: throw image_format_not_supported();
582  case CL_BUILD_PROGRAM_FAILURE: throw build_program_failure();
583  case CL_MAP_FAILURE: throw map_failure();
584 
585  case CL_INVALID_VALUE: throw invalid_value();
586  case CL_INVALID_DEVICE_TYPE: throw invalid_device_type();
587  case CL_INVALID_PLATFORM: throw invalid_platform();
588  case CL_INVALID_DEVICE: throw invalid_device();
589  case CL_INVALID_CONTEXT: throw invalid_context();
590  case CL_INVALID_QUEUE_PROPERTIES: throw invalid_queue_properties();
591  case CL_INVALID_COMMAND_QUEUE: throw invalid_command_queue();
592  case CL_INVALID_HOST_PTR: throw invalid_host_ptr();
593  case CL_INVALID_MEM_OBJECT: throw invalid_mem_object();
594  case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: throw invalid_image_format_descriptor();
595  case CL_INVALID_IMAGE_SIZE: throw invalid_image_size();
596  case CL_INVALID_SAMPLER: throw invalid_sampler();
597  case CL_INVALID_BINARY: throw invalid_binary();
598  case CL_INVALID_BUILD_OPTIONS: throw invalid_build_options();
599  case CL_INVALID_PROGRAM: throw invalid_program();
600  case CL_INVALID_PROGRAM_EXECUTABLE: throw invalid_program_executable();
601  case CL_INVALID_KERNEL_NAME: throw invalid_kernel_name();
602  case CL_INVALID_KERNEL_DEFINITION: throw invalid_kernel_definition();
603  case CL_INVALID_KERNEL: throw invalid_kernel();
604  case CL_INVALID_ARG_INDEX: throw invalid_arg_index();
605  case CL_INVALID_ARG_VALUE: throw invalid_arg_value();
606  case CL_INVALID_ARG_SIZE: throw invalid_arg_size();
607  case CL_INVALID_KERNEL_ARGS: throw invalid_kernel_args();
608  case CL_INVALID_WORK_DIMENSION: throw invalid_work_dimension();
609  case CL_INVALID_WORK_GROUP_SIZE: throw invalid_work_group_size();
610  case CL_INVALID_WORK_ITEM_SIZE: throw invalid_work_item_size();
611  case CL_INVALID_GLOBAL_OFFSET: throw invalid_global_offset();
612  case CL_INVALID_EVENT_WAIT_LIST: throw invalid_event_wait_list();
613  case CL_INVALID_EVENT: throw invalid_event();
614  case CL_INVALID_OPERATION: throw invalid_operation();
615  case CL_INVALID_GL_OBJECT: throw invalid_gl_object();
616  case CL_INVALID_BUFFER_SIZE: throw invalid_buffer_size();
617  case CL_INVALID_MIP_LEVEL: throw invalid_mip_level();
618  case CL_INVALID_GLOBAL_WORK_SIZE: throw invalid_global_work_size();
619  #ifdef CL_INVALID_PROPERTY
620  case CL_INVALID_PROPERTY: throw invalid_property();
621  #endif
622  // return "CL_INVALID_GLOBAL_WORK_SIZE";
623 
624  default: throw unknown_error();
625  }
626 
627  } //getErrorString
628 
633  static void checkError(cl_int err,
634  #ifdef VIENNACL_DEBUG_ALL
635  const char * file,
636  const char * func,
637  int line)
638  #else
639  const char *,
640  const char *,
641  int)
642  #endif
643  {
644  if (err != CL_SUCCESS)
645  {
646  #ifdef VIENNACL_DEBUG_ALL
647  std::cerr << "ViennaCL: Error " << err << " in function " << func << " ( "<< file << ":" << line << " ) " << std::endl;
648  #endif
649  raise_exception(err);
650  }
651  } //checkError()
652 
653  }; //struct
654 
655  #define VIENNACL_ERR_CHECK(err) viennacl::ocl::error_checker<void>::checkError(err, __FILE__, __FUNCTION__, __LINE__);
656 
657  } //namespace ocl
658 } //namespace viennacl
659 
660 #endif
661 
Exception thrown if an invalid device type is specified.
Definition: error.hpp:198
An error reporting class. Template argument is used to avoid problems with external linkage...
Definition: error.hpp:564
Exception thrown if the image size provided is invalid (e.g. zero).
Definition: error.hpp:288
Exception thrown if the OpenCL just-in-time compiler is not available.
Definition: error.hpp:88
Exception thrown if a memory object cannot be allocated. Usually the requested memory buffer is simpl...
Definition: error.hpp:98
Exception thrown if the number of work groups is invalid (usually this means that more than 256/512/7...
Definition: error.hpp:428
Exception thrown if the provided pointer to host memory is invalid.
Definition: error.hpp:258
Exception thrown if invalid build options are passed to the OpenCL just-in-time compiler.
Definition: error.hpp:318
Exception thrown if the source buffer overlaps the destination buffer when copying from device memory...
Definition: error.hpp:138
Exception thrown if the selected compute device is not available (maybe locked by another process)...
Definition: error.hpp:78
Exception thrown if the kernel argument provided has an invalid value.
Definition: error.hpp:388
Exception thrown if the host cannot provide enough memory for the datastructures in the OpenCL backen...
Definition: error.hpp:118
static void checkError(cl_int err, const char *, const char *, int)
Checks whether an OpenCL error has occured.
Definition: error.hpp:633
#define VIENNACL_BUG_REPORT_STRING
Definition: error.hpp:51
Exception thrown if the provided OpenGL (not OpenCL) object is invalid.
Definition: error.hpp:488
Exception thrown if the kernel argument index is invalid, e.g. an arg index larger than the number of...
Definition: error.hpp:378
Main namespace in ViennaCL. Holds all the basic types such as vector, matrix, etc. and defines operations upon them.
Definition: cpu_ram.hpp:29
Exception thrown if an invalid OpenCL platform is provided to an OpenCL function. ...
Definition: error.hpp:208
Exception thrown if there is no built program exectuable available for the device.
Definition: error.hpp:338
Exception thrown if the provided miplevel is greater than zero, but the OpenGL implementation does no...
Definition: error.hpp:508
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:358
Exception thrown if there is a mismatch in image formats for the operands.
Definition: error.hpp:148
Exception thrown if an OpenCL program object handle is invalid (e.g. not initialized).
Definition: error.hpp:328
Exception thrown if interoperability of OpenCL with other frameworks collide.
Definition: error.hpp:478
Exception thrown if the compute device is out of resources (either global memory, registers...
Definition: error.hpp:108
Exception thrown if the user wants to use double precision arithmetics, but the device does not suppo...
Definition: error.hpp:548
Exception thrown if an invalid OpenCL device is provided to an OpenCL function.
Definition: error.hpp:218
Exception thrown if the provided buffer size is invalid (e.g. zero)
Definition: error.hpp:498
Exception thrown if the provided event object (of type cl_event) is invalid.
Definition: error.hpp:468
Exception thrown if the arguments to an OpenCL kernel have an invalid size e.g. not sizeof(cl_mem))...
Definition: error.hpp:398
Exception thrown if the kernel arguments are invalid and/or do not fit the kernel parameter list...
Definition: error.hpp:408
Exception thrown if an invalid OpenCL memory object (of type cl_mem) is passed to an OpenCL funciton...
Definition: error.hpp:268
Exception thrown if an invalid OpenCL context is provided to an OpenCL function.
Definition: error.hpp:228
static void raise_exception(cl_int err)
Trows exceptions that reflect OpenCL error codes.
Definition: error.hpp:568
Exception thrown if the total number of work items is invalid (for example, not divisible by the numb...
Definition: error.hpp:518
Exception thrown if the work dimension is invalid (usually this means that the work dimension was set...
Definition: error.hpp:418
Exception thrown if the provided kernel name is invalid (e.g. not part of the program provided)...
Definition: error.hpp:348
Exception thrown if an invalid OpenCL command queue is provided to an OpenCL function.
Definition: error.hpp:248
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:368
Exception thrown in the case that a requested compute device was not found.
Definition: error.hpp:68
Exception thrown if the provided offset for get_global_id() in OpenCL kernels is invalid.
Definition: error.hpp:448
Exception thrown if an invalid property is provided to a function (vague value).
Definition: error.hpp:528
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:128
Exception thrown if the provided event wait list is invalid.
Definition: error.hpp:458
Exception thrown if an invalid image format descriptor is provided.
Definition: error.hpp:278
Exception thrown if the OpenCL program cannot be built, usually due to a syntax error in the OpenCL c...
Definition: error.hpp:168
Exception thrown if the number of work items per work group invalid (usually this means that more tha...
Definition: error.hpp:438
Exception thrown if the requested image format is not supported.
Definition: error.hpp:158
Exception thrown if the OpenCL binary (generated from the jit-compiler or loaded from some other loca...
Definition: error.hpp:308
Exception thrown if an invalid sampler is provided for an image.
Definition: error.hpp:298
Exception thrown if the mapping of device memory to the host memory space failed. ...
Definition: error.hpp:178
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:538
Exception thrown if invalid OpenCL command queue properties are provided when creating a command queu...
Definition: error.hpp:238
Exception thrown is an invalid value is provided to an OpenCL function.
Definition: error.hpp:188