stdgpu

Caractéristiques | Exemples | Commencer | Contribution | Licence | Contact

Caractéristiques

STDGPU est une bibliothèque open source fournissant des structures de données GPU génériques pour une gestion des données rapide et fiable.

• Bibliothèque C ++ 17 légère avec des dépendances minimales
• Backends CUDA , OpenMP et Hip (expérimental)
• Conteneurs GPU de type STL familiers
• Fonctions de conteneur agnostiques de haut niveau comme insert(begin, end) , pour écrire le code C ++ partagé
• Fonctions de conteneur indigène de bas niveau comme find(key) , pour écrire des noyaux Cuda personnalisés, etc.
• Interopérabilité avec des algorithmes de GPU de poussée

Au lieu de fournir un autre écosystème, STDGPU est conçu pour être une bibliothèque de conteneurs légère . Les bibliothèques précédentes telles que Thrust, Vexcl, ArrayFire ou Boost.Compute se concentrent sur l'implémentation rapide et efficace de divers algorithmes et ne fonctionnent que sur des données stockées contiguës. STDGPU suit une approche orthogonale et se concentre sur la gestion des données rapide et fiable pour permettre le développement rapide d'algorithmes GPU plus généraux et flexibles tout comme leurs homologues CPU.

En son cœur, STDGPU propose les structures et conteneurs de données GPU suivants:

atomic & atomic_ref Types et références primitives atomiques	bitset Tableau de bits économe en espace	deque File d'attente à double extrémité de taille dynamique
queue d'attente et stack Adaptateurs de conteneurs	unordered_map & unordered_set Collection hachée de clés uniques et de paires de valeurs clés	vector Tableau contigu de taille dynamiquement

De plus, STDGPU fournit également d'autres fonctionnalités d'assistance couramment utilisées dans algorithm , bit , contract , cstddef , execution , functional , iterator , limits , memory , mutex , numeric , ranges , type_traits , utility .

Exemples

Afin d'effectuer de manière fiable des tâches complexes sur le GPU, STDGPU propose des interfaces flexibles qui peuvent être utilisées dans le code agnostique , par exemple via les algorithmes fournis par la poussée, ainsi que dans le code natif , par exemple dans les grains CUDA personnalisés.

Par exemple, STDGPU est largement utilisé dans Slamcast, un système de téléprésence en direct évolutif, pour implémenter une reconstruction de scène 3D à grande échelle en temps réel ainsi que le streaming de données 3D en temps réel entre un serveur et un nombre arbitraire de clients distants.

Code agnostique . Dans le contexte de Slamcast, une tâche simple est l'intégration d'une gamme de blocs mis à jour dans l'ensemble sans double de blocs en file d'attente pour le streaming de données qui peut être exprimé très facilement:

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

Code natif . Des opérations plus complexes telles que la création de l'ensemble sans double de blocs mises à jour ou d'autres algorithmes peuvent être implémentées nativement, par exemple dans des grains CUDA personnalisés avec le backend CUDA de STDGPU activé:

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

Plus d'exemples peuvent être trouvés dans le répertoire examples .

Commencer

STDGPU nécessite un compilateur C ++ 17 ainsi que des dépendances backend minimales et peut être facilement construite et intégrée dans votre projet via Cmake :

• Bâtiment de Source
• Intégrer dans votre projet

Plus de lignes directrices ainsi qu'une introduction complète dans la conception et l'API de STDGPU se trouvent dans la documentation.

Contributif

Pour plus d'informations sur la façon de contribuer, consultez la section contributive de la documentation.

Licence

Distribué sous la licence Apache 2.0. Voir LICENSE pour plus d'informations.

Si vous utilisez STDGPU dans l'un de vos projets, veuillez citer les publications suivantes:

STDGPU: Structures de données de type STL efficaces sur le 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: Reconstruction 3D à grande échelle et en temps réel

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

Contact

Patrick Stotko - [email protected]