gunrock
Gunrock 2.1.0
| Beispiele | Projektvorlage | Dokumentation | Github -Aktionen |
|---|
Gunrock 1 ist eine CUDA-Bibliothek für die speziell für die GPU entwickelte Grafikverarbeitung. Es verwendet eine hochrangige , massensynchrone/asynchrone , datenzentrierte Abstraktion, die sich auf Operationen an Scheitelpunkt- oder Edgegrenzen konzentriert. Gunrock erreicht ein Gleichgewicht zwischen Leistung und Ausdruckskraft durch die Kopplung von Hochleistungs-GPU-Computerprimitiven und Optimierungsstrategien, insbesondere im Bereich des feinkörnigen Lastausgleichs, mit einem Programmiermodell auf hoher Ebene, mit dem Programmierer schnell neue Graph-Primitiven entwickeln können, die von einem Knoten mit kleinem Codegröße und minimalem GPU-Programmieren von GPU-Programmen skalieren.
| Zweig | Zweck | Version | Status |
|---|---|---|---|
main | Die Standardzweig, portiert aus gunrock/essentials , dient als offizielle Veröffentlichungszweig. | 2.xx | Aktiv |
develop | Entwicklungs -Feature -Zweig, portiert aus gunrock/essentials . | 2.xx | Aktiv |
master | Vorherige Veröffentlichungszweig für gunrock/gunrock Version 1.xx -Schnittstelle bewahrt die gesamte Feststellungsgeschichte. | 1.xx | Veraltet |
dev | Vorheriger Entwicklungszweig für gunrock/gunrock . Alle Änderungen haben sich jetzt im master verschmiert. | 1.xx | Veraltet |
Stellen Sie vor dem Erstellen von Gunrock sicher, dass Cuda Toolkit 2 auf Ihrem System installiert ist. Andere externe Abhängigkeiten wie NVIDIA/thrust , NVIDIA/cub usw. werden automatisch mit cmake abgerufen.
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 Eine detaillierte Erklärung finden Sie in der vollständigen Dokumentation. Das folgende Beispiel zeigt einfache APIs unter Verwendung von Gunrocks datenorientiertem, massensynchronem Programmiermodell. Wir implementieren die Breite-First-Suche nach GPUs. Dieses Beispiel überspringt die Setup -Phase des Erstellens eines problem_t und enactor_t -Struktur und springt direkt in den tatsächlichen Algorithmus.
Wir bereiten unsere Grenze zunächst mit dem ersten Quellscheitelpunkt vor, um Push-basierte BFS-Durchfahrten zu beginnen. Ein einfacher f->push_back(source) platziert den anfänglichen Scheitelpunkt, den wir für unsere erste Iteration verwenden werden.
void prepare_frontier ( frontier_t * f,
gcuda:: multi_context_t & context) override {
auto P = this -> get_problem ();
f-> push_back (P-> param . single_source );
}Wir beginnen dann unsere iterative Schleife, die iteriert, bis eine Konvergenzbedingung erfüllt ist. Wenn keine Bedingung angegeben wurde, konvergiert die Schleife, wenn die Grenze leer ist.
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);
}Include/Gunrock/Algorithmen/bfs.hxx
Vielen Dank, dass Sie unsere Arbeit zitiert haben.
@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 ist das Urheberrecht der Regenten der University of California. Die Bibliothek, Beispiele und alle Quellcode werden unter Apache 2.0 veröffentlicht.
Dieses Repository wurde von https://github.com/gunrock/essentials verschoben, und der frühere Geschichte ist mit Tags und unter master Branch erhalten. Lesen Sie mehr über Gunrock und Essentials in unserem Vision Paper: Essentials of Parallel Graph Analytics. ↩
Empfohlener CUDA V11.5.1 oder höher aufgrund der Unterstützung von Stream -geordneten Speicherballokatoren. ↩
