thrust
Thrust 2.1.0
| Exemples | Éclair divin | Documentation |
|---|
Thrust est la bibliothèque d'algorithmes parallèles C++ qui a inspiré l'introduction d'algorithmes parallèles dans la bibliothèque standard C++. L'interface de haut niveau de Thrust améliore considérablement la productivité des programmeurs tout en permettant la portabilité des performances entre les GPU et les processeurs multicœurs. Il s'appuie sur des cadres de programmation parallèles établis (tels que CUDA, TBB et OpenMP). Il fournit également un certain nombre de fonctionnalités à usage général similaires à celles trouvées dans la bibliothèque standard C++.
La bibliothèque standard NVIDIA C++ est un projet open source ; il est disponible sur GitHub et inclus dans le SDK NVIDIA HPC et le Toolkit CUDA. Si l'un de ces SDK est installé, aucun indicateur d'installation ou de compilateur supplémentaire n'est nécessaire pour utiliser libcu++.
La poussée s’apprend mieux à travers des exemples.
L'exemple suivant génère des nombres aléatoires en série, puis les transfère vers un périphérique parallèle où ils sont triés.
# include < thrust/host_vector.h >
# include < thrust/device_vector.h >
# include < thrust/generate.h >
# include < thrust/sort.h >
# include < thrust/copy.h >
# include < thrust/random.h >
int main () {
// Generate 32M random numbers serially.
thrust::default_random_engine rng ( 1337 );
thrust::uniform_int_distribution< int > dist;
thrust::host_vector< int > h_vec ( 32 << 20 );
thrust::generate (h_vec. begin (), h_vec. end (), [&] { return dist (rng); });
// Transfer data to the device.
thrust::device_vector< int > 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 ());
}A voir sur Godbolt
Cet exemple montre le calcul de la somme de certains nombres aléatoires en parallèle :
# include < thrust/host_vector.h >
# include < thrust/device_vector.h >
# include < thrust/generate.h >
# include < thrust/reduce.h >
# include < thrust/functional.h >
# include < thrust/random.h >
int main () {
// Generate random data serially.
thrust::default_random_engine rng ( 1337 );
thrust::uniform_real_distribution< double > dist (- 50.0 , 50.0 );
thrust::host_vector< double > 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< double > d_vec = h_vec;
double x = thrust::reduce (d_vec. begin (), d_vec. end (), 0 , thrust::plus< int >());
}A voir sur Godbolt
Cet exemple montre comment effectuer une telle réduction de manière asynchrone :
# include < thrust/host_vector.h >
# include < thrust/device_vector.h >
# include < thrust/generate.h >
# include < thrust/async/copy.h >
# include < thrust/async/reduce.h >
# include < thrust/functional.h >
# include < thrust/random.h >
# include < numeric >
int main () {
// Generate 32M random numbers serially.
thrust::default_random_engine rng ( 123456 );
thrust::uniform_real_distribution< double > dist (- 50.0 , 50.0 );
thrust::host_vector< double > h_vec ( 32 << 20 );
thrust::generate (h_vec. begin (), h_vec. end (), [&] { return dist (rng); });
// Asynchronously transfer to the device.
thrust::device_vector< double > 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< double > f0 = thrust::async::reduce (thrust::device. after (e),
d_vec. begin (), d_vec. end (),
0.0 , thrust::plus< double >());
// 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< double >());
}A voir sur Godbolt
Thrust est une bibliothèque d'en-tête uniquement ; il n'est pas nécessaire de créer ou d'installer le projet, sauf si vous souhaitez exécuter les tests unitaires Thrust.
La boîte à outils CUDA fournit une version récente du code source de Thrust dans include/thrust . Cela conviendra à la plupart des utilisateurs.
Les utilisateurs qui souhaitent contribuer à Thrust ou essayer de nouvelles fonctionnalités doivent cloner de manière récursive le référentiel Thrust Github :
git clone --recursive https://github.com/NVIDIA/thrust.git
Pour les projets basés sur CMake, nous fournissons un package CMake à utiliser avec find_package . Consultez le fichier README de CMake pour plus d'informations. Thrust peut également être ajouté via add_subdirectory ou des outils tels que CMake Package Manager.
Pour les projets non-CMake, compilez avec :
-I<thrust repo root> )-I<thrust repo root>/dependencies/libcudacxx/ )-I<thrust repo root>/dependencies/cub/ )-DTHRUST_HOST_SYSTEM=THRUST_HOST_SYSTEM_XXX , où XXX est CPP (série, par défaut), OMP (OpenMP) ou TBB (Intel TBB)-DTHRUST_DEVICE_SYSTEM=THRUST_DEVICE_SYSTEM_XXX , où XXX est CPP , OMP , TBB ou CUDA (par défaut). Thrust utilise le système de construction CMake pour créer des tests unitaires, des exemples et des tests d'en-tête. Pour créer Thrust en tant que développeur, il est recommandé d'utiliser notre système de développement conteneurisé :
# 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.bashCela fait l'équivalent de ce qui suit, mais dans un environnement conteneurisé propre sur lequel toutes les dépendances sont installées :
# 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 Par défaut, un système hôte série CPP , un système de périphériques accélérés CUDA et la norme C++14 sont utilisés. Cela peut être modifié dans CMake et via des indicateurs vers ci/local/build.bash
Plus d'informations sur la configuration de votre build Thrust et la création d'une pull request peuvent être trouvées dans la section de contribution.
Thrust est un projet open source développé sur GitHub. Thrust est distribué sous la licence Apache v2.0 avec exceptions LLVM ; certaines parties sont distribuées sous la licence Apache v2.0 et la licence Boost v1.0.
