gunrock
Gunrock 2.1.0
| Exemplos | Modelo de projeto | Documentação | Ações do GitHub |
|---|
O Gunrock 1 é uma biblioteca CUDA para processamento de gráficos projetado especificamente para a GPU. Ele usa uma abstração de alto nível , síncrona/assíncrona e síncrona , focada nas operações em fronteiras de vértices ou borda. O Gunrock alcança um equilíbrio entre desempenho e expressividade, acoplando primitivas de computação de GPU de alto desempenho e estratégias de otimização, particularmente na área de balanceamento de carga de granulação fina, com um modelo de programação de alto nível que permite que os programadores desenvolvam rapidamente novos primitivos gráficos que escalem um para muitos GPUs em um nó com tamanho pequeno e minimalismo GP.
| Filial | Propósito | Versão | Status |
|---|---|---|---|
main | A filial padrão, portada da gunrock/essentials , serve como a filial oficial de liberação. | 2.xx | Ativo |
develop | Ramo de características de desenvolvimento, portado de gunrock/essentials . | 2.xx | Ativo |
master | Filial anterior de lançamento para gunrock/gunrock Versão 1.xx Interface, preserva todos os comprometa o histórico. | 1.xx | Descontinuado |
dev | Ramo de Desenvolvimento anterior para gunrock/gunrock . Todas as mudanças agora mescladas no master . | 1.xx | Descontinuado |
Antes de construir o Gunrock, certifique -se de ter o CUDA Toolkit 2 instalado no seu sistema. Outras dependências externas, como NVIDIA/thrust , NVIDIA/cub , etc. são buscadas automaticamente 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 uma explicação detalhada, consulte a documentação completa. O exemplo a seguir mostra APIs simples usando o modelo de programação síncrona-síncrona e síncrona a granel da Gunrock, implementamos a primeira pesquisa na GPUs. Este exemplo ignora a fase de configuração da criação de um problem_t e enactor_t Struct e pula diretamente no algoritmo real.
Primeiro, preparamos nossa fronteira com o vértice da fonte inicial para iniciar o Traversal BFS baseado em push. Um simples f->push_back(source) coloca o vértice inicial que usaremos para nossa primeira iteração.
void prepare_frontier ( frontier_t * f,
gcuda:: multi_context_t & context) override {
auto P = this -> get_problem ();
f-> push_back (P-> param . single_source );
}Em seguida, começamos nosso loop iterativo, que itera até que uma condição de convergência seja atendida. Se nenhuma condição foi especificada, o loop converge quando a fronteira está vazia.
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
Obrigado por citar nosso trabalho.
@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 é direitos autorais dos regentes da Universidade da Califórnia. A biblioteca, os exemplos e todo o código -fonte são lançados no Apache 2.0.
Este repositório foi transferido de https://github.com/gunrock/essentials e o histórico anterior é preservado com tags e no master Branch. Leia mais sobre Gunrock e itens essenciais em nosso artigo de visão: itens essenciais da análise de gráficos paralelos. ↩
CUDA V1.5.1 recomendado devido ao suporte a alocadores de memória ordenados por fluxo. ↩
