gunrock
Gunrock 2.1.0
| Exemples | Modèle de projet | Documentation | Actions github |
|---|
Gunrock 1 est une bibliothèque CUDA pour le traitement des graphiques conçu spécifiquement pour le GPU. Il utilise une abstraction de haut niveau , synchrone / asynchrone et asynchrone , axée sur les opérations sur le sommet ou les frontières de bord. Gunrock réalise un équilibre entre les performances et l'expressivité en couplant les primitives informatiques de GPU haute performance et les stratégies d'optimisation, en particulier dans le domaine de l'équilibrage de la charge à grains fins, avec un modèle de programmation de haut niveau qui permet aux programmeurs de développer rapidement des primitives graphiques qui évoluent d'un seul GPU sur un nœud avec une grande taille de code et un programme gpu minimal.
| Bifurquer | But | Version | Statut |
|---|---|---|---|
main | La succursale par défaut, portée de gunrock/essentials , sert de succursale de libération officielle. | 2.xx | Actif |
develop | Branche de fonctions de développement, portée de gunrock/essentials . | 2.xx | Actif |
master | Branche de libération précédente pour l'interface gunrock/gunrock version 1.xx , préserve tous les antécédents. | 1.xx | Déprécié |
dev | Branche de développement précédente pour gunrock/gunrock . Tous les changements ont maintenant fusionné dans master . | 1.xx | Déprécié |
Avant de construire Gunrock, assurez-vous que la boîte à outils CUDA 2 installée sur votre système. D'autres dépendances externes telles que NVIDIA/thrust , NVIDIA/cub , etc. sont automatiquement récupérées à l'aide de cmake .
git clone https://github.com/gunrock/gunrock.git
cd gunrock
mkdir build && cd build
cmake ..
make sssp # or for all algorithms, use: make -j$(nproc)
bin/sssp ../datasets/chesapeake/chesapeake.mtx Pour une explication détaillée, veuillez consulter la documentation complète. L'exemple suivant montre des API simples à l'aide du modèle de programmation synchronique en vrac, centré sur les données de Gunrock, nous mettons en œuvre une recherche d'abord d'abord sur les GPU. Cet exemple saute la phase de configuration de la création d'une structure problem_t et enactor_t et saute directement dans l'algorithme réel.
Nous préparons d'abord notre frontière avec le sommet source initial pour commencer la traversée BFS basée sur push. Un simple f->push_back(source) place le sommet initial que nous utiliserons pour notre première itération.
void prepare_frontier ( frontier_t * f,
gcuda:: multi_context_t & context) override {
auto P = this -> get_problem ();
f-> push_back (P-> param . single_source );
}Nous commençons ensuite notre boucle itérative, qui itère jusqu'à ce qu'une condition de convergence soit remplie. Si aucune condition n'a été spécifiée, la boucle converge lorsque la frontière est vide.
void loop (gcuda:: multi_context_t & context) override {
auto E = this -> get_enactor (); // Pointer to enactor interface.
auto P = this -> get_problem (); // Pointer to problem (data) interface.
auto G = P-> get_graph (); // Graph that we are processing.
auto single_source = P-> param . single_source ; // Initial source node.
auto distances = P-> result . distances ; // Distances array for BFS.
auto visited = P-> visited . data (). get (); // Visited map.
auto iteration = this -> iteration ; // Iteration we are on.
// Following lambda expression is applied on every source,
// neighbor, edge, weight tuple during the traversal.
// Our intent here is to find and update the minimum distance when found.
// And return which neighbor goes in the output frontier after traversal.
auto search = [=] __host__ __device__ (
vertex_t const & source, // ... source
vertex_t const & neighbor, // neighbor
edge_t const & edge, // edge
weight_t const & weight // weight (tuple).
) -> bool {
auto old_distance =
math::atomic::min (&distances[neighbor], iteration + 1 );
return (iteration + 1 < old_distance);
};
// Execute advance operator on the search lambda expression.
// Uses load_balance_t::block_mapped algorithm (try others for perf. tuning.)
operators::advance::execute<operators:: load_balance_t ::block_mapped>(
G, E, search, context);
}inclure / gunrock / algorithmes / bfs.hxx
Merci d'avoir cité notre travail.
@article { Wang:2017:GGG ,
author = { Yangzihao Wang and Yuechao Pan and Andrew Davidson
and Yuduo Wu and Carl Yang and Leyuan Wang and
Muhammad Osama and Chenshan Yuan and Weitang Liu and
Andy T. Riffel and John D. Owens } ,
title = { {G}unrock: {GPU} Graph Analytics } ,
journal = { ACM Transactions on Parallel Computing } ,
year = 2017 ,
volume = 4 ,
number = 1 ,
month = aug,
pages = { 3:1--3:49 } ,
doi = { 10.1145/3108140 } ,
ee = { http://arxiv.org/abs/1701.01170 } ,
acmauthorize = { https://dl.acm.org/doi/10.1145/3108140?cid=81100458295 } ,
url = { http://escholarship.org/uc/item/9gj6r1dj } ,
code = { https://github.com/gunrock/gunrock } ,
ucdcite = { a115 } ,
} @InProceedings { Osama:2022:EOP ,
author = { Muhammad Osama and Serban D. Porumbescu and John D. Owens } ,
title = { Essentials of Parallel Graph Analytics } ,
booktitle = { Proceedings of the Workshop on Graphs,
Architectures, Programming, and Learning } ,
year = 2022 ,
series = { GrAPL 2022 } ,
month = may,
pages = { 314--317 } ,
doi = { 10.1109/IPDPSW55747.2022.00061 } ,
url = { https://escholarship.org/uc/item/2p19z28q } ,
}Gunrock est le droit d'auteur des régents de l'Université de Californie. La bibliothèque, les exemples et tout le code source sont publiés sous Apache 2.0.
Ce référentiel a été déplacé de https://github.com/gunrock/essiventials et l'histoire précédente est conservée avec des balises et sous la branche master . En savoir plus sur Gunrock et Essentials dans notre article de vision: Essentials de l'analyse des graphiques parallèles. ↩
CUDA V11.5.1 recommandé en raison de la prise en charge des allocateurs de mémoire commandés par flux. ↩
