Lines Matching +defs:error +defs:range
94 * and the range of valid underlying OpenCL runtime versions supported.
97 * CL_HPP_MINIMUM_OPENCL_VERSION control this range. These are three digit
188 * preferred error handling mechanism but is not required.
360 cl_int error;
372 error
471 # error "CL_HPP_MINIMUM_OPENCL_VERSION must not be greater than CL_HPP_TARGET_OPENCL_VERSION"
506 #error Visual studio 2013 or another C++11-supporting compiler required
727 /*! \brief Create a new CL error exception for a given error code
730 * \param err error code value.
741 /*! \brief Get error string associated with exception
743 * \return A memory pointer to the error message string.
755 /*! \brief Get error code associated with exception
757 * \return The error code.
885 #define __VECTOR_CAPACITY_ERR CL_HPP_ERR_STR_(Vector capacity error)
983 // Temporary to avoid changing param on an error
2217 * what we wish, so we catch it and save the error.
2528 * or an error condition occurs.
2597 * what we wish, so we catch it and save the error.
2665 cl_int error;
2677 notifyFptr, data, &error);
2679 detail::errHandler(error, __CREATE_CONTEXT_ERR);
2681 *err = error;
2696 cl_int error;
2703 notifyFptr, data, &error);
2705 detail::errHandler(error, __CREATE_CONTEXT_ERR);
2707 *err = error;
2726 cl_int error;
2734 error = Platform::get(&platforms);
2735 if (error != CL_SUCCESS) {
2736 detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
2738 *err = error;
2753 error = platforms[i].getDevices(type, &devices);
2757 error = e.err();
2760 // We do error checking next anyway, and can throw there if needed
2764 if (error != CL_SUCCESS && error != CL_DEVICE_NOT_FOUND) {
2765 detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
2767 *err = error;
2790 properties, type, notifyFptr, data, &error);
2792 detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
2794 *err = error;
2953 * what we wish, so we catch it and save the error.
2959 cl_int error = 0;
2961 Context context = Context::getDefault(&error);
2962 detail::errHandler(error, __CREATE_CONTEXT_ERR);
2964 if (error != CL_SUCCESS) {
2965 default_error_ = error;
3126 cl_int error;
3129 &error);
3131 detail::errHandler(error, __CREATE_USER_EVENT_ERR);
3133 *err = error;
3682 cl_int error;
3683 object_ = ::clCreateBuffer(context(), flags, size, host_ptr, &error);
3685 detail::errHandler(error, __CREATE_BUFFER_ERR);
3687 *err = error;
3706 cl_int error;
3710 object_ = ::clCreateBuffer(context(), flags, size, host_ptr, &error);
3712 detail::errHandler(error, __CREATE_BUFFER_ERR);
3714 *err = error;
3732 cl_int error;
3750 object_ = ::clCreateBuffer(context(), flags, size, static_cast<DataType*>(&*startIterator), &error);
3752 object_ = ::clCreateBuffer(context(), flags, size, 0, &error);
3755 detail::errHandler(error, __CREATE_BUFFER_ERR);
3757 *err = error;
3761 error = cl::copy(startIterator, endIterator, *this);
3762 detail::errHandler(error, __CREATE_BUFFER_ERR);
3764 *err = error;
3849 cl_int error;
3855 &error);
3857 detail::errHandler(error, __CREATE_SUBBUFFER_ERR);
3859 *err = error;
3909 cl_int error;
3914 &error);
3916 detail::errHandler(error, __CREATE_GL_BUFFER_ERR);
3918 *err = error;
3998 cl_int error;
4003 &error);
4005 detail::errHandler(error, __CREATE_GL_BUFFER_ERR);
4007 *err = error;
4095 cl_int error;
4100 &error);
4102 detail::errHandler(error, __CREATE_GL_RENDER_BUFFER_ERR);
4104 *err = error;
4278 cl_int error;
4291 &error);
4293 detail::errHandler(error, __CREATE_IMAGE_ERR);
4295 *err = error;
4366 cl_int error;
4380 &error);
4382 detail::errHandler(error, __CREATE_IMAGE_ERR);
4384 *err = error;
4452 cl_int error;
4468 &error);
4470 detail::errHandler(error, __CREATE_IMAGE_ERR);
4472 *err = error;
4550 cl_int error;
4583 &error);
4585 detail::errHandler(error, __CREATE_IMAGE_ERR);
4587 *err = error;
4595 context(), flags,&format, width, height, row_pitch, host_ptr, &error);
4597 detail::errHandler(error, __CREATE_IMAGE2D_ERR);
4599 *err = error;
4620 cl_int error;
4639 &error);
4641 detail::errHandler(error, __CREATE_IMAGE_ERR);
4643 *err = error;
4667 cl_int error;
4705 &error);
4707 detail::errHandler(error, __CREATE_IMAGE_ERR);
4709 *err = error;
4794 cl_int error;
4801 &error);
4803 detail::errHandler(error, __CREATE_GL_TEXTURE_2D_ERR);
4805 *err = error;
4883 cl_int error;
4901 &error);
4903 detail::errHandler(error, __CREATE_IMAGE_ERR);
4905 *err = error;
4981 cl_int error;
5016 &error);
5018 detail::errHandler(error, __CREATE_IMAGE_ERR);
5020 *err = error;
5029 slice_pitch, host_ptr, &error);
5031 detail::errHandler(error, __CREATE_IMAGE3D_ERR);
5033 *err = error;
5116 cl_int error;
5123 &error);
5125 detail::errHandler(error, __CREATE_GL_TEXTURE_3D_ERR);
5127 *err = error;
5202 cl_int error;
5209 &error);
5211 detail::errHandler(error, __CREATE_GL_TEXTURE_ERR);
5213 *err = error;
5293 cl_int error;
5296 object_ = ::clCreatePipe(context(), flags, packet_size, max_packets, nullptr, &error);
5298 detail::errHandler(error, __CREATE_PIPE_ERR);
5300 *err = error;
5317 cl_int error;
5322 object_ = ::clCreatePipe(context(), flags, packet_size, max_packets, nullptr, &error);
5324 detail::errHandler(error, __CREATE_PIPE_ERR);
5326 *err = error;
5432 cl_int error;
5443 &error);
5445 detail::errHandler(error, __CREATE_SAMPLER_WITH_PROPERTIES_ERR);
5447 *err = error;
5455 &error);
5457 detail::errHandler(error, __CREATE_SAMPLER_ERR);
5459 *err = error;
5551 //! \brief Default constructor - resulting range has zero dimensions.
5560 //! \brief Constructs one-dimensional range.
5569 //! \brief Constructs two-dimensional range.
5578 //! \brief Constructs three-dimensional range.
5595 //! \brief Queries the number of dimensions in the range.
5619 //! \brief A zero-dimensional range.
5808 cl_int getSubGroupInfo(const cl::Device &dev, cl_kernel_sub_group_info name, const cl::NDRange &range, size_type* param) const
5815 pfn_clGetKernelSubGroupInfoKHR(object_, dev(), name, range.size(), range.get(), sizeof(size_type), param, nullptr),
5820 size_type getSubGroupInfo(const cl::Device &dev, const cl::NDRange &range, cl_int* err = NULL) const
5823 cl_int result = getSubGroupInfo(dev, name, range, ¶m);
6005 cl_int error;
6013 context(), (cl_uint)1, &strings, &length, &error);
6015 detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
6017 if (error == CL_SUCCESS && build) {
6019 error = ::clBuildProgram(
6031 detail::buildErrHandler(error, __BUILD_PROGRAM_ERR, getBuildInfo<CL_PROGRAM_BUILD_LOG>());
6035 *err = error;
6045 cl_int error;
6051 context(), (cl_uint)1, &strings, &length, &error);
6053 detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
6055 if (error == CL_SUCCESS && build) {
6056 error = ::clBuildProgram(
6068 detail::buildErrHandler(error, __BUILD_PROGRAM_ERR, getBuildInfo<CL_PROGRAM_BUILD_LOG>());
6072 *err = error;
6084 cl_int error;
6103 context(), (cl_uint)n, strings.data(), lengths.data(), &error);
6105 detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
6107 *err = error;
6120 cl_int error;
6138 context(), (cl_uint)n, strings.data(), lengths.data(), &error);
6140 detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
6142 *err = error;
6172 cl_int error;
6178 error = CL_INVALID_VALUE;
6179 detail::errHandler(error, __CREATE_PROGRAM_WITH_BINARY_ERR);
6181 *err = error;
6215 : NULL, &error);
6217 detail::errHandler(error, __CREATE_PROGRAM_WITH_BINARY_ERR);
6219 *err = error;
6235 cl_int error;
6249 &error);
6251 detail::errHandler(error, __CREATE_PROGRAM_WITH_BUILT_IN_KERNELS_ERR);
6253 *err = error;
6352 cl_int error = ::clCompileProgram(
6362 return detail::buildErrHandler(error, __COMPILE_PROGRAM_ERR, getBuildInfo<CL_PROGRAM_BUILD_LOG>());
6413 * On an error reading the info for any device, an empty vector of info will be returned.
6425 // If there was an initial error from getInfo return the error
6441 // On error, leave the loop and return the error code
6606 cl_int error;
6608 object_ = ::clCreateKernel(program(), name, &error);
6609 detail::errHandler(error, __CREATE_KERNEL_ERR);
6612 *err = error;
6646 /* We don't want to throw an error from this function, so we have to
6647 * catch and set the error flag.
6653 int error;
6654 Context context = Context::getDefault(&error);
6656 if (error != CL_SUCCESS) {
6657 default_error_ = error;
6696 * Will return an CL_INVALID_QUEUE_PROPERTIES error if CL_QUEUE_ON_DEVICE is specified.
6702 cl_int error;
6704 Context context = Context::getDefault(&error);
6705 detail::errHandler(error, __CREATE_CONTEXT_ERR);
6707 if (error != CL_SUCCESS) {
6709 *err = error;
6734 context(), device(), queue_properties, &error);
6737 error = CL_INVALID_QUEUE_PROPERTIES;
6740 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
6742 *err = error;
6749 context(), device(), properties, &error);
6751 detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
6753 *err = error;
6762 * Will return an CL_INVALID_QUEUE_PROPERTIES error if CL_QUEUE_ON_DEVICE is specified.
6768 cl_int error;
6770 Context context = Context::getDefault(&error);
6771 detail::errHandler(error, __CREATE_CONTEXT_ERR);
6773 if (error != CL_SUCCESS) {
6775 *err = error;
6800 context(), device(), queue_properties, &error);
6802 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
6804 *err = error;
6811 context(), device(), static_cast<cl_command_queue_properties>(properties), &error);
6813 detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
6815 *err = error;
6825 * Will return an CL_INVALID_QUEUE_PROPERTIES error if CL_QUEUE_ON_DEVICE is specified.
6832 cl_int error;
6835 error = context.getInfo(CL_CONTEXT_DEVICES, &devices);
6837 detail::errHandler(error, __CREATE_CONTEXT_ERR);
6839 if (error != CL_SUCCESS)
6842 *err = error;
6865 context(), devices[0](), queue_properties, &error);
6868 error = CL_INVALID_QUEUE_PROPERTIES;
6871 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
6873 *err = error;
6880 context(), devices[0](), properties, &error);
6882 detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
6884 *err = error;
6892 * Will return an CL_INVALID_QUEUE_PROPERTIES error if CL_QUEUE_ON_DEVICE is specified.
6899 cl_int error;
6902 error = context.getInfo(CL_CONTEXT_DEVICES, &devices);
6904 detail::errHandler(error, __CREATE_CONTEXT_ERR);
6906 if (error != CL_SUCCESS)
6909 *err = error;
6931 context(), devices[0](), queue_properties, &error);
6933 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
6935 *err = error;
6942 context(), devices[0](), static_cast<cl_command_queue_properties>(properties), &error);
6944 detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
6946 *err = error;
6954 * Will return an CL_INVALID_QUEUE_PROPERTIES error if CL_QUEUE_ON_DEVICE is specified.
6962 cl_int error;
6982 context(), device(), queue_properties, &error);
6984 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
6986 *err = error;
6993 context(), device(), properties, &error);
6995 detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
6997 *err = error;
7005 * Will return an CL_INVALID_QUEUE_PROPERTIES error if CL_QUEUE_ON_DEVICE is specified.
7013 cl_int error;
7033 context(), device(), queue_properties, &error);
7035 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
7037 *err = error;
7044 context(), device(), static_cast<cl_command_queue_properties>(properties), &error);
7046 detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
7048 *err = error;
7649 cl_int error;
7655 &error);
7657 detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
7659 *err = error;
7661 if (event != NULL && error == CL_SUCCESS)
7680 cl_int error;
7689 &error);
7691 detail::errHandler(error, __ENQUEUE_MAP_IMAGE_ERR);
7693 *err = error;
7695 if (event != NULL && error == CL_SUCCESS)
8275 cl_int error;
8285 context(), device(), queue_properties, &error);
8287 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
8289 *err = error;
8302 cl_int error;
8309 context(), device(), queue_properties, &error);
8311 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
8313 *err = error;
8327 cl_int error;
8336 context(), device(), queue_properties, &error);
8338 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
8340 *err = error;
8418 cl_int error;
8429 context(), device(), queue_properties, &error));
8431 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
8433 *err = error;
8448 cl_int error;
8457 context(), device(), queue_properties, &error));
8459 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
8461 *err = error;
8476 cl_int error;
8486 context(), device(), queue_properties, &error));
8488 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
8490 *err = error;
8521 cl_int error;
8537 object_ = ::clCreateBuffer(context(), flags, size, static_cast<DataType*>(&*startIterator), &error);
8539 object_ = ::clCreateBuffer(context(), flags, size, 0, &error);
8542 detail::errHandler(error, __CREATE_BUFFER_ERR);
8544 *err = error;
8548 CommandQueue queue(context, 0, &error);
8549 detail::errHandler(error, __CREATE_BUFFER_ERR);
8551 *err = error;
8554 error = cl::copy(queue, startIterator, endIterator, *this);
8555 detail::errHandler(error, __CREATE_BUFFER_ERR);
8557 *err = error;
8572 cl_int error;
8590 object_ = ::clCreateBuffer(context(), flags, size, static_cast<DataType*>(&*startIterator), &error);
8593 object_ = ::clCreateBuffer(context(), flags, size, 0, &error);
8596 detail::errHandler(error, __CREATE_BUFFER_ERR);
8598 *err = error;
8602 error = cl::copy(queue, startIterator, endIterator, *this);
8603 detail::errHandler(error, __CREATE_BUFFER_ERR);
8605 *err = error;
8619 cl_int error;
8620 CommandQueue queue = CommandQueue::getDefault(&error);
8622 if (error != CL_SUCCESS) {
8623 return error;
8638 cl_int error;
8639 CommandQueue queue = CommandQueue::getDefault(&error);
8641 if (error != CL_SUCCESS) {
8642 return error;
8658 cl_int error;
8659 CommandQueue queue = CommandQueue::getDefault(&error);
8660 detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
8662 *err = error;
8670 &error);
8672 detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
8674 *err = error;
8695 cl_int error;
8696 CommandQueue queue = CommandQueue::getDefault(&error);
8697 if (error != CL_SUCCESS) {
8698 return detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
8719 cl_int error;
8720 CommandQueue queue = CommandQueue::getDefault(&error);
8721 if (error != CL_SUCCESS) {
8722 return detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
8742 cl_int error;
8743 CommandQueue queue = CommandQueue::getDefault(&error);
8744 if (error != CL_SUCCESS) {
8745 return detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
8760 cl_int error;
8761 CommandQueue queue = CommandQueue::getDefault(&error);
8762 detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
8763 if (error != CL_SUCCESS) {
8764 return error;
8794 cl_int error;
8795 CommandQueue queue = CommandQueue::getDefault(&error);
8796 if (error != CL_SUCCESS) {
8797 return detail::errHandler(error, __ENQUEUE_UNMAP_MEM_OBJECT_ERR);
8816 cl_int error;
8817 CommandQueue queue = CommandQueue::getDefault(&error);
8818 if (error != CL_SUCCESS) {
8819 return detail::errHandler(error, __ENQUEUE_UNMAP_MEM_OBJECT_ERR);
8837 cl_int error;
8838 CommandQueue queue = CommandQueue::getDefault(&error);
8839 if (error != CL_SUCCESS) {
8840 return detail::errHandler(error, __ENQUEUE_UNMAP_MEM_OBJECT_ERR);
8858 cl_int error;
8859 CommandQueue queue = CommandQueue::getDefault(&error);
8861 if (error != CL_SUCCESS) {
8862 return error;
8876 cl_int error;
8877 CommandQueue queue = CommandQueue::getDefault(&error);
8878 if (error != CL_SUCCESS)
8879 return error;
8892 cl_int error;
8893 CommandQueue queue = CommandQueue::getDefault(&error);
8894 if (error != CL_SUCCESS)
8895 return error;
8909 cl_int error;
8915 static_cast<DataType*>(queue.enqueueMapBuffer(buffer, CL_TRUE, CL_MAP_WRITE, 0, byteLength, 0, 0, &error));
8917 if( error != CL_SUCCESS ) {
8918 return error;
8930 error = queue.enqueueUnmapMemObject(buffer, pointer, 0, &endEvent);
8932 if( error != CL_SUCCESS ) {
8933 return error;
8948 cl_int error;
8954 static_cast<DataType*>(queue.enqueueMapBuffer(buffer, CL_TRUE, CL_MAP_READ, 0, byteLength, 0, 0, &error));
8956 if( error != CL_SUCCESS ) {
8957 return error;
8961 error = queue.enqueueUnmapMemObject(buffer, pointer, 0, &endEvent);
8963 if( error != CL_SUCCESS ) {
8964 return error;
9007 cl_int error;
9008 CommandQueue queue = CommandQueue::getDefault(&error);
9010 if (error != CL_SUCCESS) {
9011 return error;
9043 cl_int error;
9044 CommandQueue queue = CommandQueue::getDefault(&error);
9046 if (error != CL_SUCCESS) {
9047 return error;
9078 cl_int error;
9079 CommandQueue queue = CommandQueue::getDefault(&error);
9081 if (error != CL_SUCCESS) {
9082 return error;
9111 cl_int error;
9112 CommandQueue queue = CommandQueue::getDefault(&error);
9114 if (error != CL_SUCCESS) {
9115 return error;
9141 cl_int error;
9142 CommandQueue queue = CommandQueue::getDefault(&error);
9144 if (error != CL_SUCCESS) {
9145 return error;
9169 cl_int error;
9170 CommandQueue queue = CommandQueue::getDefault(&error);
9172 if (error != CL_SUCCESS) {
9173 return error;
9195 cl_int error;
9196 CommandQueue queue = CommandQueue::getDefault(&error);
9198 if (error != CL_SUCCESS) {
9199 return error;
9221 cl_int error;
9222 CommandQueue queue = CommandQueue::getDefault(&error);
9224 if (error != CL_SUCCESS) {
9225 return error;
9241 cl_int error;
9242 CommandQueue queue = CommandQueue::getDefault(&error);
9244 if (error != CL_SUCCESS) {
9245 return error;
9253 cl_int error;
9254 CommandQueue queue = CommandQueue::getDefault(&error);
9256 if (error != CL_SUCCESS) {
9257 return error;
9517 * Enqueue kernel with support for error code.
9520 * @param error Out parameter returning the error code from the execution.
9525 cl_int &error)
9530 error = args.queue_.enqueueNDRangeKernel(