================ @@ -466,6 +466,114 @@ Unpoisoning may not be an option, if (for example) you are not maintaining the a * You are using allocator, which does not call destructor during deallocation. * You are aware that memory allocated with an allocator may be accessed, even when unused by container. +Offloading C++ Parallel Algorithms to GPUs +------------------------------------------ + +Experimental support for GPU offloading has been added to ``libc++``. The +implementation uses OpenMP target offloading to leverage GPU compute resources. +The OpenMP PSTL backend can target both NVIDIA and AMD GPUs. +However, the implementation only supports contiguous iterators, such as +iterators for ``std::vector`` or ``std::array``. +To enable the OpenMP offloading backend it must be selected with +``LIBCXX_PSTL_BACKEND=openmp`` when installing ``libc++``. Further, when +compiling a program, the user must specify the command line options +``-fopenmp -fexperimental-library -stdlib=libc++``. To install LLVM with OpenMP +offloading enabled, please read +`the LLVM OpenMP FAQ. <https://openmp.llvm.org/SupportAndFAQ.html>`_ +You may also want to to visit +`the OpenMP offloading command-line argument reference. <https://openmp.llvm.org/CommandLineArgumentReference.html#offload-command-line-arguments>`_ + +Example +~~~~~~~ + +The following is an example of offloading vector addition to a GPU using our +standard library extension. + +.. code-block:: cpp + + #include <algorithm> + #include <execution> + + template<typename T1, typename T2, typename T3> + void axpy(const T1 a,std::vector<T2>& x, std::vector<T3>& y) + { + std::transform(std::execution::par_unseq,x.begin(),x.end(), y.begin(), y.begin(), + [=](T2 xi, T3 yi){ return a*xi + yi; }); + } + +The execution policy ``std::execution::par_unseq`` states that the algorithm's +execution may be parallelized, vectorized, and migrated across threads. This is +the only execution mode that is safe to offload to GPUs, and for all other +execution modes the algorithms will execute on the CPU. +Special attention must be paid to the lambda captures when enabling GPU +offloading. If the lambda captures by reference, the user must manually map the +variables to the device. If capturing by reference, the above example could +be implemented in the following way. + +.. code-block:: cpp + + template<typename T1, typename T2, typename T3> + void axpy(const T1 a,std::vector<T2>& x, std::vector<T3>& y) + { + # pragma omp target data map(to:a) + std::transform(std::execution::par_unseq,x.begin(),x.end(), y.begin(), y.begin(), ---------------- AntonRydahl wrote:
I think they are correct, but I will const qualify the x vector. It is reading from x and y and writing to y, just like the classical BLAS AXPY routine. That corresponds to 4) from https://en.cppreference.com/w/cpp/algorithm/transform. https://github.com/llvm/llvm-project/pull/66968 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits