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.
368 cl_int error;
380 error
489 # error "CL_HPP_MINIMUM_OPENCL_VERSION must not be greater than CL_HPP_TARGET_OPENCL_VERSION"
530 #error Visual studio 2013 or another C++11-supporting compiler required
753 /*! \brief Create a new CL error exception for a given error code
756 * \param err error code value.
767 /*! \brief Get error string associated with exception
769 * \return A memory pointer to the error message string.
781 /*! \brief Get error code associated with exception
783 * \return The error code.
925 #define __VECTOR_CAPACITY_ERR CL_HPP_ERR_STR_(Vector capacity error)
1037 // Temporary to avoid changing param on an error
2211 cl_ulong getHostTimer(cl_int *error = nullptr)
2219 if (error) {
2220 *error = err;
2235 std::pair<cl_ulong, cl_ulong> getDeviceAndHostTimer(cl_int *error = nullptr)
2243 if (error) {
2244 *error = err;
2361 * what we wish, so we catch it and save the error.
2672 * or an error condition occurs.
2741 * what we wish, so we catch it and save the error.
2809 cl_int error;
2821 notifyFptr, data, &error);
2823 detail::errHandler(error, __CREATE_CONTEXT_ERR);
2825 *err = error;
2840 cl_int error;
2847 notifyFptr, data, &error);
2849 detail::errHandler(error, __CREATE_CONTEXT_ERR);
2851 *err = error;
2870 cl_int error;
2878 error = Platform::get(&platforms);
2879 if (error != CL_SUCCESS) {
2880 detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
2882 *err = error;
2897 error = platforms[i].getDevices(type, &devices);
2901 error = e.err();
2904 // We do error checking next anyway, and can throw there if needed
2908 if (error != CL_SUCCESS && error != CL_DEVICE_NOT_FOUND) {
2909 detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
2911 *err = error;
2934 properties, type, notifyFptr, data, &error);
2936 detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
2938 *err = error;
3097 * what we wish, so we catch it and save the error.
3103 cl_int error = 0;
3105 Context context = Context::getDefault(&error);
3106 detail::errHandler(error, __CREATE_CONTEXT_ERR);
3108 if (error != CL_SUCCESS) {
3109 default_error_ = error;
3270 cl_int error;
3273 &error);
3275 detail::errHandler(error, __CREATE_USER_EVENT_ERR);
3277 *err = error;
3826 cl_int error;
3827 object_ = ::clCreateBuffer(context(), flags, size, host_ptr, &error);
3829 detail::errHandler(error, __CREATE_BUFFER_ERR);
3831 *err = error;
3850 cl_int error;
3854 object_ = ::clCreateBuffer(context(), flags, size, host_ptr, &error);
3856 detail::errHandler(error, __CREATE_BUFFER_ERR);
3858 *err = error;
3876 cl_int error;
3894 object_ = ::clCreateBuffer(context(), flags, size, static_cast<DataType*>(&*startIterator), &error);
3896 object_ = ::clCreateBuffer(context(), flags, size, 0, &error);
3899 detail::errHandler(error, __CREATE_BUFFER_ERR);
3901 *err = error;
3905 error = cl::copy(startIterator, endIterator, *this);
3906 detail::errHandler(error, __CREATE_BUFFER_ERR);
3908 *err = error;
3993 cl_int error;
3999 &error);
4001 detail::errHandler(error, __CREATE_SUBBUFFER_ERR);
4003 *err = error;
4053 cl_int error;
4058 &error);
4060 detail::errHandler(error, __CREATE_GL_BUFFER_ERR);
4062 *err = error;
4142 cl_int error;
4147 &error);
4149 detail::errHandler(error, __CREATE_GL_BUFFER_ERR);
4151 *err = error;
4239 cl_int error;
4244 &error);
4246 detail::errHandler(error, __CREATE_GL_RENDER_BUFFER_ERR);
4248 *err = error;
4422 cl_int error;
4435 &error);
4437 detail::errHandler(error, __CREATE_IMAGE_ERR);
4439 *err = error;
4510 cl_int error;
4524 &error);
4526 detail::errHandler(error, __CREATE_IMAGE_ERR);
4528 *err = error;
4596 cl_int error;
4612 &error);
4614 detail::errHandler(error, __CREATE_IMAGE_ERR);
4616 *err = error;
4694 cl_int error;
4727 &error);
4729 detail::errHandler(error, __CREATE_IMAGE_ERR);
4731 *err = error;
4739 context(), flags,&format, width, height, row_pitch, host_ptr, &error);
4741 detail::errHandler(error, __CREATE_IMAGE2D_ERR);
4743 *err = error;
4764 cl_int error;
4783 &error);
4785 detail::errHandler(error, __CREATE_IMAGE_ERR);
4787 *err = error;
4811 cl_int error;
4849 &error);
4851 detail::errHandler(error, __CREATE_IMAGE_ERR);
4853 *err = error;
4938 cl_int error;
4945 &error);
4947 detail::errHandler(error, __CREATE_GL_TEXTURE_2D_ERR);
4949 *err = error;
5027 cl_int error;
5045 &error);
5047 detail::errHandler(error, __CREATE_IMAGE_ERR);
5049 *err = error;
5125 cl_int error;
5160 &error);
5162 detail::errHandler(error, __CREATE_IMAGE_ERR);
5164 *err = error;
5173 slice_pitch, host_ptr, &error);
5175 detail::errHandler(error, __CREATE_IMAGE3D_ERR);
5177 *err = error;
5260 cl_int error;
5267 &error);
5269 detail::errHandler(error, __CREATE_GL_TEXTURE_3D_ERR);
5271 *err = error;
5346 cl_int error;
5353 &error);
5355 detail::errHandler(error, __CREATE_GL_TEXTURE_ERR);
5357 *err = error;
5437 cl_int error;
5440 object_ = ::clCreatePipe(context(), flags, packet_size, max_packets, nullptr, &error);
5442 detail::errHandler(error, __CREATE_PIPE_ERR);
5444 *err = error;
5461 cl_int error;
5466 object_ = ::clCreatePipe(context(), flags, packet_size, max_packets, nullptr, &error);
5468 detail::errHandler(error, __CREATE_PIPE_ERR);
5470 *err = error;
5576 cl_int error;
5587 &error);
5589 detail::errHandler(error, __CREATE_SAMPLER_WITH_PROPERTIES_ERR);
5591 *err = error;
5599 &error);
5601 detail::errHandler(error, __CREATE_SAMPLER_ERR);
5603 *err = error;
5695 //! \brief Default constructor - resulting range has zero dimensions.
5704 //! \brief Constructs one-dimensional range.
5713 //! \brief Constructs two-dimensional range.
5722 //! \brief Constructs three-dimensional range.
5739 //! \brief Queries the number of dimensions in the range.
5763 //! \brief A zero-dimensional range.
5951 cl_int getSubGroupInfo(const cl::Device &dev, cl_kernel_sub_group_info name, const cl::NDRange &range, size_type* param) const
5956 clGetKernelSubGroupInfo(object_, dev(), name, range.size(), range.get(), sizeof(size_type), param, nullptr),
5966 pfn_clGetKernelSubGroupInfoKHR(object_, dev(), name, range.size(), range.get(), sizeof(size_type), param, nullptr),
5973 size_type getSubGroupInfo(const cl::Device &dev, const cl::NDRange &range, cl_int* err = NULL) const
5976 cl_int result = getSubGroupInfo(dev, name, range, ¶m);
6145 cl_int error;
6146 Kernel retValue(clCloneKernel(this->get(), &error));
6148 detail::errHandler(error, __CLONE_KERNEL_ERR);
6173 cl_int error;
6181 context(), (cl_uint)1, &strings, &length, &error);
6183 detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
6185 if (error == CL_SUCCESS && build) {
6187 error = ::clBuildProgram(
6199 detail::buildErrHandler(error, __BUILD_PROGRAM_ERR, getBuildInfo<CL_PROGRAM_BUILD_LOG>());
6203 *err = error;
6213 cl_int error;
6219 context(), (cl_uint)1, &strings, &length, &error);
6221 detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
6223 if (error == CL_SUCCESS && build) {
6224 error = ::clBuildProgram(
6236 detail::buildErrHandler(error, __BUILD_PROGRAM_ERR, getBuildInfo<CL_PROGRAM_BUILD_LOG>());
6240 *err = error;
6252 cl_int error;
6271 context(), (cl_uint)n, strings.data(), lengths.data(), &error);
6273 detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
6275 *err = error;
6288 cl_int error;
6306 context(), (cl_uint)n, strings.data(), lengths.data(), &error);
6308 detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
6310 *err = error;
6325 cl_int error;
6332 context(), static_cast<const void*>(IL.data()), IL.size(), &error);
6342 context(), static_cast<const void*>(IL.data()), IL.size(), &error);
6346 detail::errHandler(error, __CREATE_PROGRAM_WITH_IL_ERR);
6348 if (error == CL_SUCCESS && build) {
6350 error = ::clBuildProgram(
6362 detail::buildErrHandler(error, __BUILD_PROGRAM_ERR, getBuildInfo<CL_PROGRAM_BUILD_LOG>());
6366 *err = error;
6381 cl_int error;
6386 context(), static_cast<const void*>(IL.data()), IL.size(), &error);
6396 context(), static_cast<const void*>(IL.data()), IL.size(), &error);
6400 detail::errHandler(error, __CREATE_PROGRAM_WITH_IL_ERR);
6402 if (error == CL_SUCCESS && build) {
6403 error = ::clBuildProgram(
6415 detail::buildErrHandler(error, __BUILD_PROGRAM_ERR, getBuildInfo<CL_PROGRAM_BUILD_LOG>());
6419 *err = error;
6450 cl_int error;
6456 error = CL_INVALID_VALUE;
6457 detail::errHandler(error, __CREATE_PROGRAM_WITH_BINARY_ERR);
6459 *err = error;
6493 : NULL, &error);
6495 detail::errHandler(error, __CREATE_PROGRAM_WITH_BINARY_ERR);
6497 *err = error;
6513 cl_int error;
6527 &error);
6529 detail::errHandler(error, __CREATE_PROGRAM_WITH_BUILT_IN_KERNELS_ERR);
6531 *err = error;
6630 cl_int error = ::clCompileProgram(
6640 return detail::buildErrHandler(error, __COMPILE_PROGRAM_ERR, getBuildInfo<CL_PROGRAM_BUILD_LOG>());
6691 * On an error reading the info for any device, an empty vector of info will be returned.
6703 // If there was an initial error from getInfo return the error
6719 // On error, leave the loop and return the error code
6956 cl_int error;
6958 object_ = ::clCreateKernel(program(), name, &error);
6959 detail::errHandler(error, __CREATE_KERNEL_ERR);
6962 *err = error;
6996 /* We don't want to throw an error from this function, so we have to
6997 * catch and set the error flag.
7003 int error;
7004 Context context = Context::getDefault(&error);
7006 if (error != CL_SUCCESS) {
7007 default_error_ = error;
7046 * Will return an CL_INVALID_QUEUE_PROPERTIES error if CL_QUEUE_ON_DEVICE is specified.
7052 cl_int error;
7054 Context context = Context::getDefault(&error);
7055 detail::errHandler(error, __CREATE_CONTEXT_ERR);
7057 if (error != CL_SUCCESS) {
7059 *err = error;
7084 context(), device(), queue_properties, &error);
7087 error = CL_INVALID_QUEUE_PROPERTIES;
7090 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
7092 *err = error;
7099 context(), device(), properties, &error);
7101 detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
7103 *err = error;
7112 * Will return an CL_INVALID_QUEUE_PROPERTIES error if CL_QUEUE_ON_DEVICE is specified.
7118 cl_int error;
7120 Context context = Context::getDefault(&error);
7121 detail::errHandler(error, __CREATE_CONTEXT_ERR);
7123 if (error != CL_SUCCESS) {
7125 *err = error;
7150 context(), device(), queue_properties, &error);
7152 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
7154 *err = error;
7161 context(), device(), static_cast<cl_command_queue_properties>(properties), &error);
7163 detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
7165 *err = error;
7175 * Will return an CL_INVALID_QUEUE_PROPERTIES error if CL_QUEUE_ON_DEVICE is specified.
7182 cl_int error;
7185 error = context.getInfo(CL_CONTEXT_DEVICES, &devices);
7187 detail::errHandler(error, __CREATE_CONTEXT_ERR);
7189 if (error != CL_SUCCESS)
7192 *err = error;
7215 context(), devices[0](), queue_properties, &error);
7218 error = CL_INVALID_QUEUE_PROPERTIES;
7221 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
7223 *err = error;
7230 context(), devices[0](), properties, &error);
7232 detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
7234 *err = error;
7242 * Will return an CL_INVALID_QUEUE_PROPERTIES error if CL_QUEUE_ON_DEVICE is specified.
7249 cl_int error;
7252 error = context.getInfo(CL_CONTEXT_DEVICES, &devices);
7254 detail::errHandler(error, __CREATE_CONTEXT_ERR);
7256 if (error != CL_SUCCESS)
7259 *err = error;
7281 context(), devices[0](), queue_properties, &error);
7283 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
7285 *err = error;
7292 context(), devices[0](), static_cast<cl_command_queue_properties>(properties), &error);
7294 detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
7296 *err = error;
7304 * Will return an CL_INVALID_QUEUE_PROPERTIES error if CL_QUEUE_ON_DEVICE is specified.
7312 cl_int error;
7332 context(), device(), queue_properties, &error);
7334 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
7336 *err = error;
7343 context(), device(), properties, &error);
7345 detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
7347 *err = error;
7355 * Will return an CL_INVALID_QUEUE_PROPERTIES error if CL_QUEUE_ON_DEVICE is specified.
7363 cl_int error;
7383 context(), device(), queue_properties, &error);
7385 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
7387 *err = error;
7394 context(), device(), static_cast<cl_command_queue_properties>(properties), &error);
7396 detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
7398 *err = error;
7999 cl_int error;
8005 &error);
8007 detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
8009 *err = error;
8011 if (event != NULL && error == CL_SUCCESS)
8030 cl_int error;
8039 &error);
8041 detail::errHandler(error, __ENQUEUE_MAP_IMAGE_ERR);
8043 *err = error;
8045 if (event != NULL && error == CL_SUCCESS)
8746 cl_int error;
8756 context(), device(), queue_properties, &error);
8758 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
8760 *err = error;
8773 cl_int error;
8780 context(), device(), queue_properties, &error);
8782 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
8784 *err = error;
8798 cl_int error;
8807 context(), device(), queue_properties, &error);
8809 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
8811 *err = error;
8889 cl_int error;
8900 context(), device(), queue_properties, &error));
8902 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
8904 *err = error;
8919 cl_int error;
8928 context(), device(), queue_properties, &error));
8930 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
8932 *err = error;
8947 cl_int error;
8957 context(), device(), queue_properties, &error));
8959 detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
8961 *err = error;
8978 cl_int error;
8979 error = clSetDefaultDeviceCommandQueue(context.get(), device.get(), default_queue.get());
8981 detail::errHandler(error, __SET_DEFAULT_DEVICE_COMMAND_QUEUE_ERR);
8983 *err = error;
9023 cl_int error;
9039 object_ = ::clCreateBuffer(context(), flags, size, static_cast<DataType*>(&*startIterator), &error);
9041 object_ = ::clCreateBuffer(context(), flags, size, 0, &error);
9044 detail::errHandler(error, __CREATE_BUFFER_ERR);
9046 *err = error;
9050 CommandQueue queue(context, 0, &error);
9051 detail::errHandler(error, __CREATE_BUFFER_ERR);
9053 *err = error;
9056 error = cl::copy(queue, startIterator, endIterator, *this);
9057 detail::errHandler(error, __CREATE_BUFFER_ERR);
9059 *err = error;
9074 cl_int error;
9092 object_ = ::clCreateBuffer(context(), flags, size, static_cast<DataType*>(&*startIterator), &error);
9095 object_ = ::clCreateBuffer(context(), flags, size, 0, &error);
9098 detail::errHandler(error, __CREATE_BUFFER_ERR);
9100 *err = error;
9104 error = cl::copy(queue, startIterator, endIterator, *this);
9105 detail::errHandler(error, __CREATE_BUFFER_ERR);
9107 *err = error;
9121 cl_int error;
9122 CommandQueue queue = CommandQueue::getDefault(&error);
9124 if (error != CL_SUCCESS) {
9125 return error;
9140 cl_int error;
9141 CommandQueue queue = CommandQueue::getDefault(&error);
9143 if (error != CL_SUCCESS) {
9144 return error;
9160 cl_int error;
9161 CommandQueue queue = CommandQueue::getDefault(&error);
9162 detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
9164 *err = error;
9172 &error);
9174 detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
9176 *err = error;
9197 cl_int error;
9198 CommandQueue queue = CommandQueue::getDefault(&error);
9199 if (error != CL_SUCCESS) {
9200 return detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
9221 cl_int error;
9222 CommandQueue queue = CommandQueue::getDefault(&error);
9223 if (error != CL_SUCCESS) {
9224 return detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
9244 cl_int error;
9245 CommandQueue queue = CommandQueue::getDefault(&error);
9246 if (error != CL_SUCCESS) {
9247 return detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
9262 cl_int error;
9263 CommandQueue queue = CommandQueue::getDefault(&error);
9264 detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
9265 if (error != CL_SUCCESS) {
9266 return error;
9296 cl_int error;
9297 CommandQueue queue = CommandQueue::getDefault(&error);
9298 if (error != CL_SUCCESS) {
9299 return detail::errHandler(error, __ENQUEUE_UNMAP_MEM_OBJECT_ERR);
9318 cl_int error;
9319 CommandQueue queue = CommandQueue::getDefault(&error);
9320 if (error != CL_SUCCESS) {
9321 return detail::errHandler(error, __ENQUEUE_UNMAP_MEM_OBJECT_ERR);
9339 cl_int error;
9340 CommandQueue queue = CommandQueue::getDefault(&error);
9341 if (error != CL_SUCCESS) {
9342 return detail::errHandler(error, __ENQUEUE_UNMAP_MEM_OBJECT_ERR);
9360 cl_int error;
9361 CommandQueue queue = CommandQueue::getDefault(&error);
9363 if (error != CL_SUCCESS) {
9364 return error;
9378 cl_int error;
9379 CommandQueue queue = CommandQueue::getDefault(&error);
9380 if (error != CL_SUCCESS)
9381 return error;
9394 cl_int error;
9395 CommandQueue queue = CommandQueue::getDefault(&error);
9396 if (error != CL_SUCCESS)
9397 return error;
9411 cl_int error;
9417 static_cast<DataType*>(queue.enqueueMapBuffer(buffer, CL_TRUE, CL_MAP_WRITE, 0, byteLength, 0, 0, &error));
9419 if( error != CL_SUCCESS ) {
9420 return error;
9432 error = queue.enqueueUnmapMemObject(buffer, pointer, 0, &endEvent);
9434 if( error != CL_SUCCESS ) {
9435 return error;
9450 cl_int error;
9456 static_cast<DataType*>(queue.enqueueMapBuffer(buffer, CL_TRUE, CL_MAP_READ, 0, byteLength, 0, 0, &error));
9458 if( error != CL_SUCCESS ) {
9459 return error;
9463 error = queue.enqueueUnmapMemObject(buffer, pointer, 0, &endEvent);
9465 if( error != CL_SUCCESS ) {
9466 return error;
9509 cl_int error;
9510 CommandQueue queue = CommandQueue::getDefault(&error);
9512 if (error != CL_SUCCESS) {
9513 return error;
9545 cl_int error;
9546 CommandQueue queue = CommandQueue::getDefault(&error);
9548 if (error != CL_SUCCESS) {
9549 return error;
9580 cl_int error;
9581 CommandQueue queue = CommandQueue::getDefault(&error);
9583 if (error != CL_SUCCESS) {
9584 return error;
9613 cl_int error;
9614 CommandQueue queue = CommandQueue::getDefault(&error);
9616 if (error != CL_SUCCESS) {
9617 return error;
9643 cl_int error;
9644 CommandQueue queue = CommandQueue::getDefault(&error);
9646 if (error != CL_SUCCESS) {
9647 return error;
9671 cl_int error;
9672 CommandQueue queue = CommandQueue::getDefault(&error);
9674 if (error != CL_SUCCESS) {
9675 return error;
9697 cl_int error;
9698 CommandQueue queue = CommandQueue::getDefault(&error);
9700 if (error != CL_SUCCESS) {
9701 return error;
9723 cl_int error;
9724 CommandQueue queue = CommandQueue::getDefault(&error);
9726 if (error != CL_SUCCESS) {
9727 return error;
9743 cl_int error;
9744 CommandQueue queue = CommandQueue::getDefault(&error);
9746 if (error != CL_SUCCESS) {
9747 return error;
9755 cl_int error;
9756 CommandQueue queue = CommandQueue::getDefault(&error);
9758 if (error != CL_SUCCESS) {
9759 return error;
10019 * Enqueue kernel with support for error code.
10022 * @param error Out parameter returning the error code from the execution.
10027 cl_int &error)
10032 error = args.queue_.enqueueNDRangeKernel(