stdgpu

Características | Ejemplos | Comenzando | Contribuyente | Licencia | Contacto

Características

STDGPU es una biblioteca de código abierto que proporciona estructuras genéricas de datos de GPU para una gestión de datos rápida y confiable.

• Biblioteca Ligera de C ++ 17 con dependencias mínimas
• CUDA , OpenMP y Backends (experimentales)
• Contenedores familiares de GPU tipo STL
• Funciones de contenedores agnósticos de alto nivel como insert(begin, end) , para escribir código C ++ compartido
• Funciones de contenedores nativos de bajo nivel como find(key) , para escribir núcleos CUDA personalizados, etc.
• Interoperabilidad con algoritmos de GPU de empuje

En lugar de proporcionar otro ecosistema, STDGPU está diseñado para ser una biblioteca de contenedores ligero . Bibliotecas anteriores como Thrust, VEXCL, Arrayfire o Boost.Compute se centran en la implementación rápida y eficiente de varios algoritmos y solo operan en datos almacenados contiguamente. STDGPU sigue un enfoque ortogonal y se centra en la gestión de datos rápida y confiable para permitir el rápido desarrollo de algoritmos de GPU más generales y flexibles al igual que sus contrapartes de la CPU.

En el fondo, STDGPU ofrece las siguientes estructuras y contenedores de datos de la GPU:

atomic & atomic_ref Tipos y referencias atómicas primitivas	bitset Matriz de bits de eficiencia espacial	deque Cola de doble extremo de tamaño dinámico
queue y stack Adaptadores de contenedores	unordered_map y unordered_set Colección de hash de claves únicas y pares de valores clave	vector Matriz contigua de tamaño dinámico

Además, STDGPU también proporciona una funcionalidad auxiliar más utilizada en algorithm , bit , contract , cstddef , execution , functional , iterator , limits , memory , mutex , numeric , ranges , type_traits , utility .

Ejemplos

Para realizar tareas complejas de manera confiable en la GPU, STDGPU ofrece interfaces flexibles que pueden usarse tanto en código agnóstico , por ejemplo, a través de los algoritmos proporcionados por empuje, así como en el código nativo , por ejemplo, en núcleos CUDA personalizados.

Por ejemplo, STDGPU se usa ampliamente en Slamcast, un sistema de telepresencia en vivo escalable, para implementar la reconstrucción de escenas 3D en tiempo real en tiempo real, así como la transmisión de datos 3D en tiempo real entre un servidor y un número arbitrario de clientes remotos.

Código Agnóstico . En el contexto de Slamcast, una tarea simple es la integración de una gama de bloques actualizados en el conjunto de bloques de cola duplicados para la transmisión de datos que se puede expresar muy convenientemente:

# 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 . Las operaciones más complejas, como la creación del conjunto gratuito de bloques actualizados u otros algoritmos, se pueden implementar de forma nativa, por ejemplo, en núcleos CUDA personalizados con el backend CUDA de STDGPU habilitado

# 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]);
        }
    }
}

Se pueden encontrar más ejemplos en el directorio de examples .

Empezando

STDGPU requiere un compilador C ++ 17, así como dependencias mínimas de backend y se pueden construir e integrarse fácilmente en su proyecto a través de CMake :

• Edificio de la fuente
• Integrando en su proyecto

Se pueden encontrar más pautas, así como una introducción completa sobre el diseño y la API de STDGPU en la documentación.

Que contribuye

Para obtener información detallada sobre cómo contribuir, consulte la sección contribuyente en la documentación.

Licencia

Distribuido bajo la licencia Apache 2.0. Vea LICENSE para más información.

Si usa stdgpu en uno de sus proyectos, cite las siguientes publicaciones:

STDGPU: estructuras de datos eficientes en forma de STL en la 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: reconstrucción y transmisión en 3D en tiempo real a gran escala para la telepresencia en vivo de múltiples clientes inmersivos

 @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
}

Contacto

Patrick Stotko - [email protected]