Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/NVIDIA/thrust

[ARCHIVED] The C++ parallel algorithms library. See https://github.com/NVIDIA/cccl
https://github.com/NVIDIA/thrust

algorithms cpp cpp11 cpp14 cpp17 cpp20 cuda cxx cxx11 cxx14 cxx17 cxx20 gpu gpu-computing nvidia nvidia-hpc-sdk thrust

Last synced: about 2 months ago
JSON representation

[ARCHIVED] The C++ parallel algorithms library. See https://github.com/NVIDIA/cccl

Awesome Lists containing this project

README

        

:warning: **The Thrust repository has been archived and is now part of the unified [nvidia/cccl repository](https://github.com/nvidia/cccl). See the [announcement here](https://github.com/NVIDIA/cccl/discussions/520) for more information. Please visit the new repository for the latest updates.** :warning:

# Thrust: The C++ Parallel Algorithms Library

Examples
Godbolt
Documentation

Thrust is the C++ parallel algorithms library which inspired the introduction
of parallel algorithms to the C++ Standard Library.
Thrust's **high-level** interface greatly enhances programmer **productivity**
while enabling performance portability between GPUs and multicore CPUs.
It builds on top of established parallel programming frameworks (such as CUDA,
TBB, and OpenMP).
It also provides a number of general-purpose facilities similar to those found
in the C++ Standard Library.

The NVIDIA C++ Standard Library is an open source project; it is available on
[GitHub] and included in the NVIDIA HPC SDK and CUDA Toolkit.
If you have one of those SDKs installed, no additional installation or compiler
flags are needed to use libcu++.

## Examples

Thrust is best learned through examples.

The following example generates random numbers serially and then transfers them
to a parallel device where they are sorted.

```cuda
#include
#include
#include
#include
#include
#include

int main() {
// Generate 32M random numbers serially.
thrust::default_random_engine rng(1337);
thrust::uniform_int_distribution dist;
thrust::host_vector h_vec(32 << 20);
thrust::generate(h_vec.begin(), h_vec.end(), [&] { return dist(rng); });

// Transfer data to the device.
thrust::device_vector d_vec = h_vec;

// Sort data on the device.
thrust::sort(d_vec.begin(), d_vec.end());

// Transfer data back to host.
thrust::copy(d_vec.begin(), d_vec.end(), h_vec.begin());
}
```

[See it on Godbolt](https://godbolt.org/z/GeWEd8Er9)

This example demonstrates computing the sum of some random numbers in parallel:

```cuda
#include
#include
#include
#include
#include
#include

int main() {
// Generate random data serially.
thrust::default_random_engine rng(1337);
thrust::uniform_real_distribution dist(-50.0, 50.0);
thrust::host_vector h_vec(32 << 20);
thrust::generate(h_vec.begin(), h_vec.end(), [&] { return dist(rng); });

// Transfer to device and compute the sum.
thrust::device_vector d_vec = h_vec;
double x = thrust::reduce(d_vec.begin(), d_vec.end(), 0, thrust::plus());
}
```

[See it on Godbolt](https://godbolt.org/z/cnsbWWME7)

This example show how to perform such a reduction asynchronously:

```cuda
#include
#include
#include
#include
#include
#include
#include
#include

int main() {
// Generate 32M random numbers serially.
thrust::default_random_engine rng(123456);
thrust::uniform_real_distribution dist(-50.0, 50.0);
thrust::host_vector h_vec(32 << 20);
thrust::generate(h_vec.begin(), h_vec.end(), [&] { return dist(rng); });

// Asynchronously transfer to the device.
thrust::device_vector d_vec(h_vec.size());
thrust::device_event e = thrust::async::copy(h_vec.begin(), h_vec.end(),
d_vec.begin());

// After the transfer completes, asynchronously compute the sum on the device.
thrust::device_future f0 = thrust::async::reduce(thrust::device.after(e),
d_vec.begin(), d_vec.end(),
0.0, thrust::plus());

// While the sum is being computed on the device, compute the sum serially on
// the host.
double f1 = std::accumulate(h_vec.begin(), h_vec.end(), 0.0, thrust::plus());
}
```

[See it on Godbolt](https://godbolt.org/z/be54efaKj)

## Getting The Thrust Source Code

Thrust is a header-only library; there is no need to build or install the project
unless you want to run the Thrust unit tests.

The CUDA Toolkit provides a recent release of the Thrust source code in
`include/thrust`. This will be suitable for most users.

Users that wish to contribute to Thrust or try out newer features should
recursively clone the Thrust Github repository:

```
git clone --recursive https://github.com/NVIDIA/thrust.git
```

## Using Thrust From Your Project

For CMake-based projects, we provide a CMake package for use with
`find_package`. See the [CMake README](thrust/cmake/README.md) for more
information. Thrust can also be added via `add_subdirectory` or tools like
the [CMake Package Manager](https://github.com/cpm-cmake/CPM.cmake).

For non-CMake projects, compile with:
- The Thrust include path (`-I`)
- The libcu++ include path (`-I/dependencies/libcudacxx/`)
- The CUB include path, if using the CUDA device system (`-I/dependencies/cub/`)
- By default, the CPP host system and CUDA device system are used.
These can be changed using compiler definitions:
- `-DTHRUST_HOST_SYSTEM=THRUST_HOST_SYSTEM_XXX`,
where `XXX` is `CPP` (serial, default), `OMP` (OpenMP), or `TBB` (Intel TBB)
- `-DTHRUST_DEVICE_SYSTEM=THRUST_DEVICE_SYSTEM_XXX`, where `XXX` is
`CPP`, `OMP`, `TBB`, or `CUDA` (default).

## Developing Thrust

Thrust uses the [CMake build system] to build unit tests, examples, and header
tests.
To build Thrust as a developer, it is recommended that you use our
containerized development system:

```bash
# Clone Thrust and CUB repos recursively:
git clone --recursive https://github.com/NVIDIA/thrust.git
cd thrust

# Build and run tests and examples:
ci/local/build.bash
```

That does the equivalent of the following, but in a clean containerized
environment which has all dependencies installed:

```bash
# Clone Thrust and CUB repos recursively:
git clone --recursive https://github.com/NVIDIA/thrust.git
cd thrust

# Create build directory:
mkdir build
cd build

# Configure -- use one of the following:
cmake .. # Command line interface.
ccmake .. # ncurses GUI (Linux only).
cmake-gui # Graphical UI, set source/build directories in the app.

# Build:
cmake --build . -j ${NUM_JOBS} # Invokes make (or ninja, etc).

# Run tests and examples:
ctest
```

By default, a serial `CPP` host system, `CUDA` accelerated device system, and
C++14 standard are used.
This can be changed in CMake and via flags to `ci/local/build.bash`

More information on configuring your Thrust build and creating a pull request
can be found in the [contributing section].

## Licensing

Thrust is an open source project developed on [GitHub].
Thrust is distributed under the [Apache License v2.0 with LLVM Exceptions];
some parts are distributed under the [Apache License v2.0] and the
[Boost License v1.0].

## CI Status

[GitHub]: https://github.com/nvidia/thrust

[CMake section]: https://nvidia.github.io/thrust/setup/cmake_options.html
[contributing section]: https://nvidia.github.io/thrust/contributing.html

[CMake build system]: https://cmake.org

[Apache License v2.0 with LLVM Exceptions]: https://llvm.org/LICENSE.txt
[Apache License v2.0]: https://www.apache.org/licenses/LICENSE-2.0.txt
[Boost License v1.0]: https://www.boost.org/LICENSE_1_0.txt