Operating system support currently strongly focuses on Linux. On Mac, only the CPU backend is expected to work. Windows support with CPU and CUDA backends is experimental, see Using AdaptiveCpp on Windows.
In order to successfully build and install AdaptiveCpp, the following dependencies must be installed for all backends:
- python 3 (for the
acppcompiler driver) cmake- the Boost C++ libraries (in particular
boost.fiber,boost.contextand for the unit testsboost.test)- it may be helpful to set the
BOOST_ROOTcmakevariable to the path to the root directory of Boost you wish to use ifcmakedoes not find it automatically - Note for boost 1.78 users: There seems to be a bug in the build system for boost 1.78, causing the compiled fiber and context libraries not to be copied to the installation directory. You will have to copy these libraries manually to the installation directory. In binary packages from some distribution repositories this issue is fixed. You might be only affected when building boost manually from source.
- it may be helpful to set the
In addition, the various supported compilation flows and programming models have additional requirements:
For a standard installation that has the most important features enabled, you will additionally need to install an official LLVM release >= 14. Please do not use a development version or vendor-specific fork of LLVM. This can be very conveniently be achieved e.g. using https://apt.llvm.org (detailed instructions).
Next, ensure that you have the stacks installed that you want to target (e.g. CUDA, ROCm, OpenCL etc).
AdaptiveCpp will automatically enable all backends that it finds on the system, so in typical scenarios, the following is sufficient:
git clone https://github.com/AdaptiveCpp/AdaptiveCpp
cd AdaptiveCpp
mkdir build && cd build
cmake -DCMAKE_INSTALL_PREFIX=/your/desired/install/location ..
make install
If it does not find some backends or does not pick up the right LLVM, please look at the documentation for the individual components linked below.
Advanced users may want to customize their installation more, or use features that are not so commonly used. The following sections describe requirements for individual components in more detail.
| Compilation flow | Target hardware | Short description | Requirements |
|---|---|---|---|
omp.library-only |
Any CPU | OpenMP CPU backend | Any OpenMP compiler |
omp.accelerated |
Any CPU supported by LLVM | OpenMP CPU backend (compiler-accelerated) | LLVM >= 11 |
cuda.integrated-multipass |
NVIDIA GPUs | CUDA backend (clang) | CUDA >= 10, LLVM >= 10 |
cuda.explicit-multipass |
NVIDIA GPUs | CUDA backend (clang, can be targeted simultaneously with other backends) | CUDA >= 10, LLVM 11 or 13+ |
cuda-nvcxx |
NVIDIA GPUs | CUDA backend (nvc++) | Latest NVIDIA HPC SDK |
hip.integrated-multipass |
AMD GPUs (supported by ROCm) | HIP backend (clang) | ROCm >= 4.0, LLVM >= 10 |
generic |
NVIDIA, AMD, Intel GPUs, OpenCL SPIR-V devices | Generic single-pass compiler | LLVM >= 14. When dispatching kernels to AMD hardware, ROCm >= 5.3 is recommended and LLVM must be <= the ROCm LLVM version. When dispatching to NVIDIA, clang needs nvptx64 backend enabled. AdaptiveCpp runtime backends for the respective target hardware need to be available. |
Note: Building against libc++ instead of libstdc++ is only expected to work for the generic target. Additionally, AdaptiveCpp must have been built using the same standard library that the user code is linked against.
libc++ is currently not supported for the C++ standard parallelism offloading model.
- SYCL: (No SYCL-specific requirements)
- C++ standard parallelism: See here for dependencies.
Please make sure to read the instructions below for the dependencies that apply to your use case.
Follow these instructions.
Follow these instructions
Follow these instructions
Follow these instructions.
Follow these instructions.
Once the software requirements mentioned above are met, clone the repository:
$ git clone https://github.com/AdaptiveCpp/AdaptiveCpp
Then, create a build directory and compile AdaptiveCpp. As described below, some backends and compilation flows must be configured with specific cmake arguments which should be passed during the cmake step.
$ cd <build directory>
$ cmake -DCMAKE_INSTALL_PREFIX=<installation prefix> <more optional options, e.g. to configure the LLVM dependency> <AdaptiveCpp source directory>
$ make install
The default installation prefix is /usr/local. Change this to your liking.
Note: AdaptiveCpp needs to be installed to function correctly; don't replace "make install" with just "make"!
-DCMAKE_CXX_COMPILERshould be pointed to the C++ compiler to compile AdaptiveCpp with. Note that this also sets the default C++ compiler for the CPU backend when using acpp once AdaptiveCpp is installed. This can however also be modified later usingHIPSYCL_CPU_CXX.
-DWITH_SSCP_COMPILER=OFF/ONcan be used to explicitly enable or disable the generic SSCP compiler.
-DCMAKE_CXX_COMPILERcan be used to set the default OpenMP compiler.
-DWITH_ACCELERATED_CPU=OFF/ONcan be used to explicitly disable/enable CPU acceleration. Support for CPU acceleration is enabled by default when enabling the LLVM dependency, and LLVM is sufficiently new.
- See the CUDA installation instructions instructions (section on clang).
- See the CUDA installation instructions instructions (section on nvc++).
- See the ROCm installation instructions instructions.
On Mac, only the CPU backends are supported. The required steps are analogous to Linux.
For experimental building on Windows (CPU and CUDA backends) see the corresponding wiki.
The omp.accelerated CPU compilation flow is unsupported on Windows.