Unduh stdgpu - Unduh Kode Sumber stdgpu

stdgpu

C/C++

stdgpu 1.3.0

Unduh

Fitur

STDGPU adalah perpustakaan open-source yang menyediakan struktur data GPU generik untuk manajemen data yang cepat dan andal.

Perpustakaan C ++ 17 ringan dengan dependensi minimal
Cadangan cuda , openmp , dan hip (eksperimental)
Wadah GPU seperti STL yang akrab
Fungsi wadah agnostik tingkat tinggi seperti insert(begin, end) , untuk menulis kode C ++ bersama
Fungsi wadah asli tingkat rendah seperti find(key) , untuk menulis kernel cuda khusus, dll.
Interoperabilitas dengan algoritma dorong GPU

Alih -alih menyediakan ekosistem lain, STDGPU dirancang untuk menjadi perpustakaan kontainer yang ringan . Perpustakaan sebelumnya seperti Thrust, VEXCL, Arrayfire atau Boost. Perkotaan fokus pada implementasi yang cepat dan efisien dari berbagai algoritma dan hanya beroperasi pada data yang disimpan secara berdekatan. STDGPU mengikuti pendekatan ortogonal dan berfokus pada manajemen data yang cepat dan andal untuk memungkinkan pengembangan cepat algoritma GPU yang lebih umum dan fleksibel seperti rekan -rekan CPU mereka.

Pada intinya, STDGPU menawarkan struktur dan wadah data GPU berikut:

`atomic` & `atomic_ref` Jenis dan referensi primitif atom	`bitset` Array bit yang hemat ruang	`deque` Antrian ganda berukuran dinamis
`queue` & `stack` Adaptor kontainer	`unordered_map` & `unordered_set` Koleksi hash dari kunci unik dan pasangan bernilai kunci	`vector` Array yang berdekatan secara dinamis

Selain itu, STDGPU juga menyediakan fungsionalitas helper yang umum digunakan dalam algorithm , bit , contract , cstddef , execution , functional , iterator , limits , memory , mutex , numeric , ranges , type_traits , utility .

Contoh

Untuk melakukan tugas -tugas kompleks secara andal pada GPU, STDGPU menawarkan antarmuka fleksibel yang dapat digunakan dalam kedua kode agnostik , misalnya melalui algoritma yang disediakan oleh dorong, serta dalam kode asli , misalnya dalam kernel CUDA khusus.

Misalnya, STDGPU secara luas digunakan dalam Slamcast, sistem telepresence langsung yang dapat diskalakan, untuk mengimplementasikan rekonstruksi adegan 3D skala besar, serta streaming data 3D real-time antara server dan jumlah klien jarak jauh yang sewenang-wenang.

Kode agnostik . Dalam konteks slamcast, tugas sederhana adalah integrasi berbagai blok yang diperbarui ke dalam set blok antrian bebas rangkap untuk streaming data yang dapat diekspresikan dengan sangat mudah:

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

Kode asli . Operasi yang lebih kompleks seperti pembuatan set blok yang diperbarui bebas duplikat atau algoritma lainnya dapat diimplementasikan secara asli, misalnya dalam kernel CUDA khusus dengan backend CUDA STDGPU diaktifkan:

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

Lebih banyak contoh dapat ditemukan di direktori examples .

Memulai

STDGPU membutuhkan kompiler C ++ 17 serta dependensi backend minimal dan dapat dengan mudah dibangun dan diintegrasikan ke dalam proyek Anda melalui CMake :

Membangun dari sumber
Integrasi ke dalam proyek Anda

Lebih banyak pedoman serta pengantar komprehensif ke dalam desain dan API STDGPU dapat ditemukan dalam dokumentasi.

Berkontribusi

Untuk informasi terperinci tentang cara berkontribusi, lihat bagian yang berkontribusi dalam dokumentasi.

Lisensi

Didistribusikan di bawah lisensi Apache 2.0. Lihat LICENSE untuk informasi lebih lanjut.

Jika Anda menggunakan STDGPU di salah satu proyek Anda, silakan kutip publikasi berikut:

STDGPU: Struktur data seperti STL yang efisien di 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: Rekonstruksi dan streaming 3D skala besar, waktu nyata untuk telepresensi hidup multi-klien yang mendalam

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