stdgpu -Download - stdgpu -Quellcode Download

stdgpu

C/C++

stdgpu 1.3.0

Herunterladen

Merkmale

STDGPU ist eine Open-Source-Bibliothek, die generische GPU-Datenstrukturen für eine schnelle und zuverlässige Datenverwaltung bietet.

Leichte C ++ 17 Bibliothek mit minimalen Abhängigkeiten
CUDA , OpenMP und HIP (experimentelle) Backends
Vertraute STL-ähnliche GPU-Behälter
High-Level-, agnostische Containerfunktionen wie insert(begin, end) , um gemeinsam genutzten C ++-Code zu schreiben
Low-Level-, native Containerfunktionen wie find(key) , um benutzerdefinierte Cuda-Kerne usw. zu schreiben, usw.
Interoperabilität mit Schub -GPU -Algorithmen

Anstatt ein weiteres Ökosystem bereitzustellen, ist STDGPU als leichte Containerbibliothek ausgelegt. Frühere Bibliotheken wie Thrust, Vexcl, ArrayFire oder Boost.com, konzentrieren sich auf die schnelle und effiziente Implementierung verschiedener Algorithmen und arbeiten nur mit zusammenhängenden Daten. STDGPU verfolgt einen orthogonalen Ansatz und konzentriert sich auf das schnelle und zuverlässige Datenmanagement, um die schnelle Entwicklung allgemeinerer und flexiblerer GPU -Algorithmen genau wie ihre CPU -Gegenstücke zu ermöglichen.

Im Herzen bietet STDGPU die folgenden GPU -Datenstrukturen und -container:

`atomic` & `atomic_ref` Atomic Primitive Typen und Referenzen	`bitset` Platzeffizientes Bitarray	`deque` Dynamisch doppelt geendete Warteschlange
`queue` & `stack` Containeradapter	`unordered_map` & Under `unordered_set` Hashed-Sammlung einzigartiger Schlüssel und Schlüsselwertpaare	`vector` Dynamisch großes angrenzendes Array

Darüber hinaus liefert STDGPU auch weiterhin häufig verwendete Helferfunktionen in algorithm , bit , contract , cstddef , execution , functional , iterator , limits , memory , mutex , numeric , ranges , type_traits , utility .

Beispiele

Um komplexe Aufgaben in der GPU zuverlässig auszuführen, bietet STDGPU flexible Schnittstellen, die sowohl in Agnostic Code , z.

Zum Beispiel wird STDGPU in Slamcast, einem skalierbaren Live-Telepräsenzsystem, ausführlich verwendet, um eine 3D-Szene-Rekonstruktion in Echtzeit sowie in Echtzeit-3D-Daten zu implementieren, die zwischen einem Server und einer beliebigen Anzahl von Remote-Clients streamen.

Agnostischer Code . Im Kontext von SLAMCAST ist eine einfache Aufgabe die Integration einer Reihe aktualisierter Blöcke in den doppelten Satz von Warteschlangenblöcken für das Datenstreaming, die sehr bequem ausgedrückt werden können:

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

Einheimischer Code . Komplexere Vorgänge wie die Erstellung des doppelten freien Satzes von aktualisierten Blöcken oder anderen Algorithmen können nativ implementiert werden, z. B. in benutzerdefinierten CUDA-Kerneln mit dem CUDA-Backend von STDGPU aktiviert:

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

Weitere Beispiele finden Sie im examples .

Erste Schritte

STDGPU benötigt einen C ++ 17 -Compiler sowie minimale Backend -Abhängigkeiten und kann über CMAKE leicht in Ihr Projekt aufgebaut und integriert werden:

Gebäude aus der Quelle
Integration in Ihr Projekt

Weitere Richtlinien sowie eine umfassende Einführung in das Design und die API von STDGPU finden Sie in der Dokumentation.

Beitragen

Ausführliche Informationen zum Beitrag zum Beitrag finden Sie im Bereich Abschnitt in der Dokumentation.

Lizenz

Unter der Apache 2.0 -Lizenz verteilt. Weitere Informationen finden Sie LICENSE .

Wenn Sie STDGPU in einem Ihrer Projekte verwenden, geben Sie bitte die folgenden Veröffentlichungen an:

STDGPU: Effiziente STL-ähnliche Datenstrukturen an der 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: groß an

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