gunrock
Gunrock 2.1.0
| Ejemplos | Plantilla de proyecto | Documentación | Acciones de Github |
|---|
Gunrock 1 es una biblioteca CUDA para el procesamiento de gráficos diseñado específicamente para la GPU. Utiliza una abstracción de alto nivel , sincrónica/asincrónica , centrada en los datos centrada en las operaciones en fronteras de vértice o borde. Gunrock logra un equilibrio entre el rendimiento y la expresividad al acoplar las primitivas de computación de GPU de alto rendimiento y las estrategias de optimización, particularmente en el área de equilibrio de carga de grano fino, con un modelo de programación de alto nivel que permite a los programadores desarrollar rápidamente nuevas primitivas gráficas que se escallan de una a muchas GPU en un tamaño de código pequeño con un tamaño de código pequeño y un conocimiento de programas mínimos de GPU.
| Rama | Objetivo | Versión | Estado |
|---|---|---|---|
main | La rama predeterminada, portada de gunrock/essentials , sirve como la rama de lanzamiento oficial. | 2.xx | Activo |
develop | Rama de características de desarrollo, portada de gunrock/essentials . | 2.xx | Activo |
master | Rama de lanzamiento anterior para la interfaz gunrock/gunrock Versión 1.xx , conserva todo el historial de confirmación. | 1.xx | Desapercibido |
dev | Rama de desarrollo previo para gunrock/gunrock . Todos los cambios ahora se fusionaron en master . | 1.xx | Desapercibido |
Antes de construir Gunrock, asegúrese de tener CUDA Toolkit 2 instalado en su sistema. Otras dependencias externas como NVIDIA/thrust , NVIDIA/cub , etc. se obtienen automáticamente usando 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 Para obtener una explicación detallada, consulte la documentación completa. El siguiente ejemplo muestra API simples que usan el modelo de programación sincrónico centrado en los datos de GunRock, implementamos la búsqueda de amplitud primera en las GPU. Este ejemplo omite la fase de configuración de crear un problem_t y enactor_t struct y salta directamente al algoritmo real.
Primero preparamos nuestra frontera con el vértice de origen inicial para comenzar el recorrido BFS basado en Push. Un simple f->push_back(source) coloca el vértice inicial que utilizaremos para nuestra primera iteración.
void prepare_frontier ( frontier_t * f,
gcuda:: multi_context_t & context) override {
auto P = this -> get_problem ();
f-> push_back (P-> param . single_source );
}Luego comenzamos nuestro bucle iterativo, que itera hasta que se ha cumplido una condición de convergencia. Si no se ha especificado ninguna condición, el bucle converge cuando la frontera está vacía.
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);
}incluir/gunrock/algoritmos/bfs.hxx
Gracias por citar nuestro trabajo.
@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 es derechos de autor de los regentes de la Universidad de California. La biblioteca, los ejemplos y todos los códigos fuente se lanzan bajo Apache 2.0.
Este repositorio se ha trasladado de https://github.com/guncrock/essentials y el historial anterior se conserva con etiquetas y bajo rama master . Lea más sobre Gunrock and Essentials en nuestro documento de visión: elementos esenciales del análisis de gráficos paralelos. ↩
Recomendado CUDA V11.5.1 o superior debido al soporte para los asignadores de memoria ordenados por la corriente. ↩
