stdgpu

Recursos | Exemplos | Introdução | Contribuindo | Licença | Contato

Características

O STDGPU é uma biblioteca de código aberto que fornece estruturas de dados GPU genéricas para gerenciamento de dados rápido e confiável.

• Biblioteca leve C ++ 17 com dependências mínimas
• CUDA , OPENMP e HIP (experimental) back -end
• Contêineres familiares de GPU, tipo STL
• Funções de contêiner agnóstico de alto nível como insert(begin, end) , para escrever código C ++ compartilhado
• Funções de contêineres nativos de baixo nível, como find(key) , para escrever kernels CUDA personalizados, etc.
• Interoperabilidade com algoritmos de GPU de impulso

Em vez de fornecer mais um ecossistema, o STDGPU foi projetado para ser uma biblioteca de contêineres leves . Bibliotecas anteriores, como impulso, vexcl, Arrayfire ou boost.compute, concentre -se na implementação rápida e eficiente de vários algoritmos e operam apenas dados armazenados contiguamente. O STDGPU segue uma abordagem ortogonal e se concentra no gerenciamento de dados rápido e confiável para permitir o rápido desenvolvimento de algoritmos GPU mais gerais e flexíveis, assim como seus colegas de CPU.

No seu coração, o STDGPU oferece as seguintes estruturas e contêineres de dados da GPU:

atomic & atomic_ref Tipos e referências primitivas atômicas	bitset Array de bits com eficiência espacial	deque Fila de tamanho duplo de tamanho dinâmico
queue e stack Adaptadores de contêineres	unordered_map & unordered_set Coleção hashed de chaves exclusivas e pares de valor-chave	vector Matriz contígua de tamanho dinâmico

Além disso, o STDGPU também fornece mais funcionalidade auxiliar comumente usada no algorithm , bit , contract , cstddef , execution , functional , iterator , limits , memory , mutex , numeric , ranges , type_traits , utility .

Exemplos

Para executar de maneira confiável tarefas complexas na GPU, o STDGPU oferece interfaces flexíveis que podem ser usadas no código agnóstico , por exemplo, através dos algoritmos fornecidos pelo impulso, bem como no código nativo , por exemplo, nos kernels CUDA personalizados.

Por exemplo, o STDGPU é amplamente utilizado no SLAMCAST, um sistema de telepresença ao vivo escalável, para implementar a reconstrução de cenas em larga escala e em larga escala em tempo real, bem como o streaming de dados 3D em tempo real entre um servidor e um número arbitrário de clientes remotos.

Código agnóstico . No contexto do SLAMCAST, uma tarefa simples é a integração de uma variedade de blocos atualizados no conjunto de blocos de fila sem duplicado para transmissão de dados que podem ser expressos de maneira muito conveniente:

# include < stdgpu/cstddef.h >             // stdgpu::index_t
# include < stdgpu/iterator.h >            // stdgpu::make_device
# include < stdgpu/unordered_set.cuh >     // stdgpu::unordered_set

class stream_set
{
public:
    void
    add_blocks ( const short3* blocks,
               const stdgpu:: index_t n)
    {
        set. insert ( stdgpu::make_device (blocks),
                   stdgpu::make_device (blocks + n));
    }

    // Further functions

private:
    stdgpu::unordered_set<short3> set;
    // Further members
};

Código nativo . Operações mais complexas, como a criação do conjunto de blocos atualizados sem duplicados ou outros algoritmos, pode ser implementado nativamente, por exemplo, em kernels CUDA personalizados com o back-end do CUDA da STDGPU ativado:

# include < stdgpu/cstddef.h >             // stdgpu::index_t
# include < stdgpu/unordered_map.cuh >     // stdgpu::unordered_map
# include < stdgpu/unordered_set.cuh >     // stdgpu::unordered_set

__global__ void
compute_update_set ( const short3* blocks,
                   const stdgpu:: index_t n,
                   const stdgpu::unordered_map<short3, voxel*> tsdf_block_map,
                   stdgpu::unordered_set<short3> mc_update_set)
{
    // Global thread index
    stdgpu:: index_t i = blockIdx. x * blockDim. x + threadIdx. x ;
    if (i >= n) return ;

    short3 b_i = blocks[i];

    // Neighboring candidate blocks for the update
    short3 mc_blocks[ 8 ]
    = {
        short3 (b_i. x - 0 , b_i. y - 0 , b_i. z - 0 ),
        short3 (b_i. x - 1 , b_i. y - 0 , b_i. z - 0 ),
        short3 (b_i. x - 0 , b_i. y - 1 , b_i. z - 0 ),
        short3 (b_i. x - 0 , b_i. y - 0 , b_i. z - 1 ),
        short3 (b_i. x - 1 , b_i. y - 1 , b_i. z - 0 ),
        short3 (b_i. x - 1 , b_i. y - 0 , b_i. z - 1 ),
        short3 (b_i. x - 0 , b_i. y - 1 , b_i. z - 1 ),
        short3 (b_i. x - 1 , b_i. y - 1 , b_i. z - 1 ),
    };

    for (stdgpu:: index_t j = 0 ; j < 8 ; ++j)
    {
        // Only consider existing neighbors
        if (tsdf_block_map. contains (mc_blocks[j]))
        {
            mc_update_set. insert (mc_blocks[j]);
        }
    }
}

Mais exemplos podem ser encontrados no diretório de examples .

Começando

O STDGPU requer um compilador C ++ 17, bem como dependências mínimas de back -end e pode ser facilmente construído e integrado ao seu projeto via cmake :

• Edifício da fonte
• Integrando em seu projeto

Mais diretrizes, bem como uma introdução abrangente no design e a API do STDGPU, podem ser encontrados na documentação.

Contribuindo

Para obter informações detalhadas sobre como contribuir, consulte a seção contribuinte na documentação.

Licença

Distribuído sob a licença Apache 2.0. Consulte LICENSE para obter mais informações.

Se você usar o STDGPU em um de seus projetos, cite as seguintes publicações:

STDGPU: estruturas de dados do tipo STL eficientes na GPU

 @UNPUBLISHED { stotko2019stdgpu ,
    author = { Stotko, P. } ,
     title = { {stdgpu: Efficient STL-like Data Structures on the GPU} } ,
      year = { 2019 } ,
     month = aug,
      note = { arXiv:1908.05936 } ,
       url = { https://arxiv.org/abs/1908.05936 }
}

Slamcast: Reconstrução 3D em larga escala e em tempo real para telepresença ao vivo imersiva de vários clientes

 @article { stotko2019slamcast ,
    author = { Stotko, P. and Krumpen, S. and Hullin, M. B. and Weinmann, M. and Klein, R. } ,
     title = { {SLAMCast: Large-Scale, Real-Time 3D Reconstruction and Streaming for Immersive Multi-Client Live Telepresence} } ,
   journal = { IEEE Transactions on Visualization and Computer Graphics } ,
    volume = { 25 } ,
    number = { 5 } ,
     pages = { 2102--2112 } ,
      year = { 2019 } ,
     month = may
}

Contato

Patrick Stotko - [email protected]