Lines Matching +full:opencl +full:- +full:clhpp
2 // Copyright (c) 2008-2020 The Khronos Group Inc.
8 // http://www.apache.org/licenses/LICENSE-2.0
19 * \brief C++ bindings for OpenCL 1.0, OpenCL 1.1, OpenCL 1.2,
20 * OpenCL 2.0, OpenCL 2.1, OpenCL 2.2, and OpenCL 3.0.
23 * Derived from the OpenCL 1.x C++ bindings written by
29 * Tom Deakin and Simon McIntosh-Smith, July 2013
30 * James Price, 2015-
32 * \date 2019-09-18
47 * http://khronosgroup.github.io/OpenCL-CLHPP/
51 * https://github.com/KhronosGroup/OpenCL-CLHPP/releases
55 * https://github.com/KhronosGroup/OpenCL-CLHPP
61 * reasonable to define C++ bindings for OpenCL.
63 * The interface is contained with a single C++ header file \em opencl.hpp and all
66 * bindings; it is enough to simply include \em opencl.hpp.
73 * fixes in the new header as well as additional OpenCL 2.0 features.
75 * reason we release it as opencl.hpp rather than a new version of cl.hpp.
79 * Due to the evolution of the underlying OpenCL API the 2.0 C++ bindings
81 * and the range of valid underlying OpenCL runtime versions supported.
85 * decimal values representing OpenCL runime versions. The default for
86 * the target is 200, representing OpenCL 2.0 and the minimum is also
91 * Note that this is a compile-time setting, and so affects linking against
107 * custom interface-compatible versions using the CL_HPP_NO_STD_ARRAY,
111 * The OpenCL 1.x versions of the C++ bindings included a size_t wrapper
114 * In the 2.0 version we have replaced this with a std::array-based interface.
118 * Finally, the program construction interface used a clumsy vector-of-pairs
120 * vector-of-vectors and vector-of-strings design. However, for backward
124 * In OpenCL 2.0 OpenCL C is not entirely backward compatibility with
125 * earlier versions. As a result a flag must be passed to the OpenCL C
126 * compiled to request OpenCL 2.0 compilation of kernels with 1.2 as
129 * For those cases the compilation defaults to OpenCL C 2.0.
132 * If more fine-grained decisions on a per-kernel bases are required
139 * - CL_HPP_TARGET_OPENCL_VERSION
141 * Defines the target OpenCL runtime version to build the header
142 * against. Defaults to 200, representing OpenCL 2.0.
144 * - CL_HPP_NO_STD_STRING
147 * defined and may be defined by the user before opencl.hpp is
150 * - CL_HPP_NO_STD_VECTOR
153 * defined and may be defined by the user before opencl.hpp is
156 * - CL_HPP_NO_STD_ARRAY
159 * defined and may be defined by the user before opencl.hpp is
162 * - CL_HPP_NO_STD_UNIQUE_PTR
166 * defined by the user before opencl.hpp is included.
168 * - CL_HPP_ENABLE_DEVICE_FISSION
170 * Enables device fission for OpenCL 1.2 platforms.
172 * - CL_HPP_ENABLE_EXCEPTIONS
177 * - CL_HPP_ENABLE_SIZE_T_COMPATIBILITY
179 * Backward compatibility option to support cl.hpp-style size_t
186 * - CL_HPP_ENABLE_PROGRAM_CONSTRUCTION_FROM_ARRAY_COMPATIBILITY
191 * - CL_HPP_CL_1_2_DEFAULT_BUILD
193 * Default to OpenCL C 1.2 compilation rather than OpenCL C 2.0
197 * - CL_HPP_USE_CL_SUB_GROUPS_KHR
201 * - CL_HPP_USE_IL_KHR
217 #include <CL/opencl.hpp>
233 if (platver.find("OpenCL 2.") != std::string::npos) {
238 std::cout << "No OpenCL 2.0 platform found.";
239 return -1;
245 return -1;
261 …utput[get_global_id(0)] = inputA[get_global_id(0)] + inputB[get_global_id(0)] + val + *(aNum->bar);
287 vectorAddProgram.build("-cl-std=CL2.0");
302 // Get and run kernel that initializes the program-scope global
317 fooPointer->bar = anSVMInt.get();
396 # pragma message("opencl.hpp: USE_DX_INTEROP is deprecated. Define CL_HPP_USE_DX_INTEROP instead")
400 # pragma message("opencl.hpp: USE_CL_DEVICE_FISSION is deprecated. Define CL_HPP_USE_CL_DEVICE_FISS…
404 # pragma message("opencl.hpp: __CL_ENABLE_EXCEPTIONS is deprecated. Define CL_HPP_ENABLE_EXCEPTIONS…
408 # pragma message("opencl.hpp: __NO_STD_VECTOR is deprecated. Define CL_HPP_NO_STD_VECTOR instead")
412 # pragma message("opencl.hpp: __NO_STD_STRING is deprecated. Define CL_HPP_NO_STD_STRING instead")
416 # pragma message("opencl.hpp: VECTOR_CLASS is deprecated. Alias cl::vector instead")
419 # pragma message("opencl.hpp: STRING_CLASS is deprecated. Alias cl::string instead.")
422 # pragma message("opencl.hpp: __CL_USER_OVERRIDE_ERROR_STRINGS is deprecated. Define CL_HPP_USER_OV…
429 # pragma message("opencl.hpp: __USE_DEV_VECTOR is no longer supported. Expect compilation errors")
432 # pragma message("opencl.hpp: __USE_DEV_STRING is no longer supported. Expect compilation errors")
437 # pragma message("opencl.hpp: CL_HPP_TARGET_OPENCL_VERSION is not defined. It will default to 300 (…
447 …a message("opencl.hpp: CL_HPP_TARGET_OPENCL_VERSION is not a valid value (100, 110, 120, 200, 210,…
452 /* Forward target OpenCL version to C headers if necessary */
473 # pragma message("opencl.hpp: CL_HPP_MINIMUM_OPENCL_VERSION is not a valid value (100, 110, 120, 20…
519 #error Visual studio 2013 or another C++11-supporting compiler required
528 #include <OpenCL/opencl.h>
530 #include <CL/opencl.h>
550 // in case they are not pre-defined
628 // Define size_type appropriately to allow backward-compatibility
634 * OpenCL C calls that require arrays of size_t values, whose
702 * \brief The OpenCL C++ bindings are defined within this namespace.
998 size_type numBinaries = param->size(); in getInfoHelper()
1041 /* Specialization for reference-counted types. This depends on the
1067 param->resize(elements); in getInfoHelper()
1097 param->assign(begin(value), prev(end(value))); in getInfoHelper()
1101 param->assign(""); in getInfoHelper()
1138 /* Specialization for reference-counted types. This depends on the
1155 err = param->retain(); in getInfoHelper()
1477 // Flags deprecated in OpenCL 2.0
1654 * OpenCL 1.2 devices do have retain/release.
1684 * OpenCL 1.1 devices do not have retain/release.
1782 highVersion += versionInfo[index]-'0'; in getVersion()
1788 lowVersion += versionInfo[index]-'0'; in getVersion()
2118 //! \brief Default constructor - performs no initialization.
2135 this->image_channel_data_type = rhs.image_channel_data_type; in operator =()
2136 this->image_channel_order = rhs.image_channel_order; in operator =()
2185 //! \brief Default constructor - initializes to NULL.
2297 clGetHostTimer(this->get(), &retVal); in getHostTimer()
2321 clGetDeviceAndHostTimer(this->get(), &(retVal.first), &(retVal.second)); in getDeviceAndHostTimer()
2356 devices->resize(ids.size()); in createSubDevices()
2403 devices->resize(ids.size()); in createSubDevices()
2501 //! \brief Default constructor - initializes to NULL.
2600 // API-owned objects. in getDevices()
2602 devices->resize(ids.size()); in getDevices()
2622 * \param devices returns a vector of OpenCL D3D10 devices found. The cl::Device
2623 * values returned in devices can be used to identify a specific OpenCL
2627 * - CL_SUCCESS if the function is executed successfully.
2629 * The application can query specific capabilities of the OpenCL device(s)
2688 // API-owned objects. in getDevices()
2690 devices->resize(ids.size()); in getDevices()
2727 platforms->resize(ids.size()); in get()
2791 * Unload the OpenCL compiler.
2792 * \note Deprecated for OpenCL 1.2. Use Platform::unloadCompiler instead.
3088 //! \brief Default constructor - initializes to NULL.
3091 /*! \brief Constructor from cl_context - takes ownership.
3099 /*! \brief Assignment operator from cl_context - takes ownership.
3172 formats->assign(begin(value), end(value)); in getSupportedImageFormats()
3176 formats->clear(); in getSupportedImageFormats()
3227 //! \brief Default constructor - initializes to NULL.
3230 /*! \brief Constructor from cl_event - takes ownership.
3241 /*! \brief Assignment operator from cl_event - takes ownership.
3370 //! \brief Default constructor - initializes to NULL.
3410 //! \brief Default constructor - initializes to NULL.
3413 /*! \brief Constructor from cl_mem - takes ownership.
3427 /*! \brief Assignment operator from cl_mem - takes ownership.
3502 * value - not the Memory class instance.
3519 // Pre-declare copy functions
3611 // Pre-declare SVM map function
3622 * STL-like allocator class for managing SVM objects provided for convenience.
3626 …* The allocator should not be used to construct a unique_ptr if we are using coarse-grained SVM mo…
3627 …* the coarse-grained management behaviour would behave incorrectly with respect to reference count…
3694 * If the allocator is coarse-grained, this will take ownership to allow
3717 // If allocation was coarse-grained then map it in allocate()
3761 p->~U(); in destroy()
3870 /*! \brief Vector alias to simplify contruction of coarse-grained SVM containers.
3876 /*! \brief Vector alias to simplify contruction of fine-grained SVM containers.
3882 /*! \brief Vector alias to simplify contruction of fine-grained SVM containers that support platfor…
3978 size_type size = sizeof(DataType)*(endIterator - startIterator); in Buffer()
4019 //! \brief Default constructor - initializes to NULL.
4022 /*! \brief Constructor from cl_mem - takes ownership.
4032 /*! \brief Assignment from cl_mem - performs shallow copy.
4101 /*! \brief Class interface for creating OpenCL buffers from ID3D10Buffer's.
4131 cl_platform platform = -1; in BufferD3D10()
4155 //! \brief Default constructor - initializes to NULL.
4158 /*! \brief Constructor from cl_mem - takes ownership.
4168 /*! \brief Assignment from cl_mem - performs shallow copy.
4244 //! \brief Default constructor - initializes to NULL.
4247 /*! \brief Constructor from cl_mem - takes ownership.
4257 /*! \brief Assignment from cl_mem - performs shallow copy.
4341 //! \brief Default constructor - initializes to NULL.
4344 /*! \brief Constructor from cl_mem - takes ownership.
4354 /*! \brief Assignment from cl_mem - performs shallow copy.
4412 //! \brief Default constructor - initializes to NULL.
4415 /*! \brief Constructor from cl_mem - takes ownership.
4425 /*! \brief Assignment from cl_mem - performs shallow copy.
4531 //! \brief Default constructor - initializes to NULL.
4534 /*! \brief Constructor from cl_mem - takes ownership.
4544 /*! \brief Assignment from cl_mem - performs shallow copy.
4621 /*! \brief Constructor from cl_mem - takes ownership.
4707 /*! \brief Constructor from cl_mem - takes ownership.
4783 // Run-time decision based on the actual platform in Image2D()
4786 useCreateImage = (version >= 0x10002); // OpenCL 1.2 or above in Image2D()
4878 * The channel order may differ as described in the OpenCL
4933 //! \brief Default constructor - initializes to NULL.
4936 /*! \brief Constructor from cl_mem - takes ownership.
4946 /*! \brief Assignment from cl_mem - performs shallow copy.
4995 * \note Deprecated for OpenCL 1.2. Please use ImageGL instead.
5029 //! \brief Default constructor - initializes to NULL.
5032 /*! \brief Constructor from cl_mem - takes ownership.
5042 /*! \brief Assignment from cl_mem - performs shallow copy.
5128 /*! \brief Constructor from cl_mem - takes ownership.
5202 // Run-time decision based on the actual platform in Image3D()
5205 useCreateImage = (version >= 0x10002); // OpenCL 1.2 or above in Image3D()
5253 //! \brief Default constructor - initializes to NULL.
5256 /*! \brief Constructor from cl_mem - takes ownership.
5266 /*! \brief Assignment from cl_mem - performs shallow copy.
5345 //! \brief Default constructor - initializes to NULL.
5348 /*! \brief Constructor from cl_mem - takes ownership.
5358 /*! \brief Assignment from cl_mem - performs shallow copy.
5403 * was performed by OpenCL anyway.
5433 /*! \brief Constructor from cl_mem - takes ownership.
5544 //! \brief Default constructor - initializes to NULL.
5547 /*! \brief Constructor from cl_mem - takes ownership.
5557 /*! \brief Assignment from cl_mem - performs shallow copy.
5632 //! \brief Default constructor - initializes to NULL.
5678 /*! \brief Constructor from cl_sampler - takes ownership.
5689 /*! \brief Assignment operator from cl_sampler - takes ownership.
5765 //! \brief Default constructor - resulting range has zero dimensions.
5774 //! \brief Constructs one-dimensional range.
5783 //! \brief Constructs two-dimensional range.
5792 //! \brief Constructs three-dimensional range.
5833 //! \brief A zero-dimensional range.
5900 //! \brief Default constructor - initializes to NULL.
5903 /*! \brief Constructor from cl_kernel - takes ownership.
5914 /*! \brief Assignment operator from cl_kernel - takes ownership.
6139 /*! \brief Enable fine-grained system SVM.
6141 * \note It is only possible to enable fine-grained system SVM if all devices
6144 * \param svmEnabled True if fine-grained system SVM is requested. False otherwise.
6146 * if no devices in the context support fine-grained system SVM.
6233 Kernel retValue(clCloneKernel(this->get(), &error)); in clone()
6279 "-cl-std=CL2.0", in Program()
6316 "-cl-std=CL2.0", in Program()
6404 * Program constructor to allow construction of program from SPIR-V or another IL.
6405 * Valid for either OpenCL >= 2.1 or when CL_HPP_USE_IL_KHR is defined.
6442 "-cl-std=CL2.0", in Program()
6458 * Program constructor to allow construction of program from SPIR-V or another IL
6460 * Valid for either OpenCL >= 2.1 or when CL_HPP_USE_IL_KHR is defined.
6495 "-cl-std=CL2.0",
6512 * Construct a program object from a list of devices and a per-device list of binaries.
6513 * \param context A valid OpenCL context in which to construct the program.
6514 * \param devices A vector of OpenCL device objects for which the program will be created.
6522 …* \param err if non-NULL will be set to CL_SUCCESS on successful operation or one of the following…
6526 …* CL_INVALID_DEVICE if OpenCL devices listed in devices are not in the list of devices associate…
6528 …* CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the OpenCL imple…
6572 binaryStatus->resize(numDevices);
6579 ? &binaryStatus->front()
6592 * \param kernelNames Semi-colon separated list of builtin kernel names
6626 /*! \brief Constructor from cl_program - takes ownership.
6856 kernels->resize(value.size());
6894 /*! \brief Sets a SPIR-V specialization constant.
6911 /*! \brief Sets a SPIR-V specialization constant.
7022 param->resize(numBinaries);
7176 // Run-time decision based on the actual platform
7179 useWithProperties = (version >= 0x20000); // OpenCL 2.0 or above
7242 // Run-time decision based on the actual platform
7245 useWithProperties = (version >= 0x20000); // OpenCL 2.0 or above
7307 // Run-time decision based on the actual platform
7310 useWithProperties = (version >= 0x20000); // OpenCL 2.0 or above
7374 // Run-time decision based on the actual platform
7377 useWithProperties = (version >= 0x20000); // OpenCL 2.0 or above
7425 // Run-time decision based on the actual platform
7428 useWithProperties = (version >= 0x20000); // OpenCL 2.0 or above
7476 // Run-time decision based on the actual platform
7479 useWithProperties = (version >= 0x20000); // OpenCL 2.0 or above
7544 /*! \brief Constructor from cl_command_queue - takes ownership.
7623 (events != NULL) ? (cl_uint) events->size() : 0,
7624 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
7648 (events != NULL) ? (cl_uint) events->size() : 0,
7649 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
7672 (events != NULL) ? (cl_uint) events->size() : 0,
7673 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
7711 (events != NULL) ? (cl_uint) events->size() : 0,
7712 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
7750 (events != NULL) ? (cl_uint) events->size() : 0,
7751 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
7787 (events != NULL) ? (cl_uint) events->size() : 0,
7788 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
7803 * The pattern type must be an accepted OpenCL data type.
7828 (events != NULL) ? (cl_uint) events->size() : 0,
7829 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
7862 (events != NULL) ? (cl_uint) events->size() : 0,
7863 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
7895 (events != NULL) ? (cl_uint) events->size() : 0,
7896 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
7924 (events != NULL) ? (cl_uint) events->size() : 0,
7925 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
7939 * This is a four component RGBA floating-point color value if
7959 (events != NULL) ? (cl_uint) events->size() : 0,
7960 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
7993 (events != NULL) ? (cl_uint) events->size() : 0,
7994 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8027 (events != NULL) ? (cl_uint) events->size() : 0,
8028 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8057 (events != NULL) ? (cl_uint) events->size() : 0,
8058 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8086 (events != NULL) ? (cl_uint) events->size() : 0,
8087 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8111 (events != NULL) ? (cl_uint) events->size() : 0,
8112 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8145 (events != NULL) ? (cl_uint) events->size() : 0,
8146 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8161 … * Enqueues a command that will allow the host to update a region of a coarse-grained SVM buffer.
8176 (events != NULL) ? (cl_uint)events->size() : 0,
8177 (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL,
8189 … * Enqueues a command that will allow the host to update a region of a coarse-grained SVM buffer.
8204 (events != NULL) ? (cl_uint)events->size() : 0,
8205 (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL,
8216 … * Enqueues a command that will allow the host to update a region of a coarse-grained SVM buffer.
8230 (events != NULL) ? (cl_uint)events->size() : 0,
8231 (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL,
8252 (events != NULL) ? (cl_uint) events->size() : 0,
8253 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8266 * Enqueues a command that will release a coarse-grained SVM buffer back to the OpenCL runtime.
8279 (events != NULL) ? (cl_uint)events->size() : 0,
8280 (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL,
8291 * Enqueues a command that will release a coarse-grained SVM buffer back to the OpenCL runtime.
8304 (events != NULL) ? (cl_uint)events->size() : 0,
8305 (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL,
8316 * Enqueues a command that will release a coarse-grained SVM buffer back to the OpenCL runtime.
8329 (events != NULL) ? (cl_uint)events->size() : 0,
8330 (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL,
8361 (events != NULL) ? (cl_uint) events->size() : 0,
8362 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8391 (events != NULL) ? (cl_uint) events->size() : 0,
8392 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8427 (events != NULL) ? (cl_uint) events->size() : 0,
8428 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8444 * @param sizes - The length from each pointer to migrate.
8460 (events != NULL) ? (cl_uint)events->size() : 0,
8461 (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL,
8489 * @param sizes - The length from each pointer to migrate.
8526 * @param sizes - The length from the beginning of each container to migrate.
8576 (events != NULL) ? (cl_uint) events->size() : 0,
8577 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8597 (events != NULL) ? (cl_uint) events->size() : 0,
8598 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8619 elements = mem_objects->size();
8630 (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0,
8632 … (mem_locs != NULL && mem_locs->size() > 0) ? (const void **) &mem_locs->front() : NULL,
8633 (events != NULL) ? (cl_uint) events->size() : 0,
8634 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8685 (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0,
8686 … (mem_objects != NULL && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): NULL,
8687 (events != NULL) ? (cl_uint) events->size() : 0,
8688 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8707 (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0,
8708 … (mem_objects != NULL && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): NULL,
8709 (events != NULL) ? (cl_uint) events->size() : 0,
8710 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8750 (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0,
8751 … (mem_objects != NULL && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): NULL,
8752 (events != NULL) ? (cl_uint) events->size() : 0,
8753 (events != NULL) ? (cl_event*) &events->front() : NULL,
8783 (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0,
8784 … (mem_objects != NULL && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): NULL,
8785 (events != NULL) ? (cl_uint) events->size() : 0,
8786 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
8924 /*! \brief Constructor from cl_command_queue - takes ownership.
8993 * function will return the pre-existing queue.
9023 * function will return the pre-existing queue.
9051 * function will return the pre-existing queue.
9145 size_type size = sizeof(DataType)*(endIterator - startIterator);
9196 size_type size = sizeof(DataType)*(endIterator - startIterator);
9278 (events != NULL) ? (cl_uint) events->size() : 0,
9279 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
9294 * update a region of a coarse-grained SVM buffer.
9318 * update a region of a coarse-grained SVM buffer.
9342 * update a region of a coarse-grained SVM buffer.
9382 (events != NULL) ? (cl_uint)events->size() : 0,
9383 (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL,
9395 * Enqueues to the default queue a command that will release a coarse-grained
9396 * SVM buffer back to the OpenCL runtime.
9417 * Enqueues to the default queue a command that will release a coarse-grained
9418 * SVM buffer back to the OpenCL runtime.
9438 * Enqueues to the default queue a command that will release a coarse-grained
9439 * SVM buffer back to the OpenCL runtime.
9522 size_type length = endIterator-startIterator;
9561 size_type length = endIterator-startIterator;
9584 * Blocking SVM map operation - performs a blocking map underneath.
9593 * Blocking SVM map operation - performs a blocking map underneath.
10058 //----------------------------------------------------------------------------------------------
10173 * Backward compatibility class to ensure that cl.hpp code works with opencl.hpp.
10214 //-------------------------------------------------------------------------------------------------…