stdgpu

คุณสมบัติ | ตัวอย่าง เริ่มต้นใช้งาน | บริจาค | ใบอนุญาต | ติดต่อ

คุณสมบัติ

STDGPU เป็นห้องสมุดโอเพนซอร์ซที่ให้บริการ โครงสร้างข้อมูล GPU ทั่วไป สำหรับการจัดการข้อมูลที่รวดเร็วและเชื่อถือได้

• ไลบรารี C ++ 17 ที่มีน้ำหนักเบาพร้อมการพึ่งพาน้อยที่สุด
• แบ็กเอนด์ Cuda , OpenMP และ สะโพก (ทดลอง)
• คอนเทนเนอร์ GPU ที่คุ้นเคยเหมือน STL
• ฟังก์ชั่น คอนเทนเนอร์ ระดับสูงเช่น insert(begin, end) เพื่อเขียนรหัส C ++ ที่ใช้ร่วมกัน
• ฟังก์ชั่นคอนเทนเนอร์ พื้นเมือง ระดับต่ำเช่น find(key) เพื่อเขียนเคอร์เนล cuda ที่กำหนดเอง ฯลฯ
• ความสามารถในการทำงานร่วมกันกับอัลกอริทึม GPU THRUST

แทนที่จะให้ระบบนิเวศอีกระบบหนึ่ง STDGPU ได้รับการออกแบบให้เป็น ห้องสมุดคอนเทนเนอร์ที่มีน้ำหนักเบา ไลบรารีก่อนหน้าเช่น THRUST, VEXCL, ArrayFire หรือ Boost.compute มุ่งเน้นไปที่การใช้งานที่รวดเร็วและมีประสิทธิภาพของอัลกอริทึมต่างๆและทำงานบนข้อมูลที่เก็บไว้อย่างต่อเนื่องเท่านั้น STDGPU ทำตาม วิธีการ orthogonal และมุ่งเน้นไปที่ การจัดการข้อมูลที่รวดเร็วและเชื่อถือได้ เพื่อเปิดใช้งานการพัฒนาอย่างรวดเร็วของอัลกอริทึม GPU ทั่วไปและยืดหยุ่นมากขึ้นเช่นเดียวกับ CPU คู่ของพวกเขา

ในใจของมัน STDGPU นำเสนอโครงสร้างข้อมูลและคอนเทนเนอร์ GPU ต่อไปนี้:

atomic & atomic_ref ชนิดและการอ้างอิงแบบดั้งเดิมอะตอม	bitset อาร์เรย์บิตที่ประหยัดพื้นที่	deque คิวคู่ขนาดสองเท่าแบบไดนามิก
queue และ stack อะแดปเตอร์คอนเทนเนอร์	unordered_map & unordered_set คอลเลกชันแฮชคีย์ที่ไม่ซ้ำกันและคู่คีย์-ค่า	vector อาร์เรย์ที่ต่อเนื่องกันขนาดไดนามิก

นอกจากนี้ STDGPU ยังให้ฟังก์ชั่นผู้ช่วยที่ใช้กันทั่วไปใน algorithm , bit , contract , cstddef , execution , functional , iterator , limits , memory , mutex , numeric , ranges , type_traits , utility

ตัวอย่าง

เพื่อที่จะดำเนินงานที่ซับซ้อนบน GPU ได้อย่างน่าเชื่อถือ stdgpu นำเสนออินเทอร์เฟซที่ยืดหยุ่นที่สามารถใช้ในทั้ง รหัสไม่เชื่อเรื่องพระเจ้า เช่นผ่านอัลกอริทึมที่จัดทำโดยแรงผลักดันเช่นเดียวกับใน รหัสดั้งเดิม เช่นในเคอร์เนล cuda ที่กำหนดเอง

ตัวอย่างเช่น STDGPU ถูกใช้อย่างกว้างขวางใน Slamcast ซึ่งเป็นระบบ telepresence สดที่ปรับขนาดได้เพื่อใช้การสร้างฉาก 3 มิติขนาดใหญ่แบบเรียลไทม์รวมถึงการสตรีมข้อมูล 3 มิติแบบเรียลไทม์ระหว่างเซิร์ฟเวอร์และไคลเอนต์ระยะไกลตามอำเภอใจ

รหัสผู้ไม่เชื่อเรื่องพระเจ้า ในบริบทของ Slamcast งานง่าย ๆ คือการรวมช่วงของบล็อกที่อัปเดตไว้ในชุดบล็อกที่ไม่มีคิวที่ซ้ำกันสำหรับการสตรีมข้อมูลซึ่งสามารถแสดงได้อย่างสะดวกสบายมาก:

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

รหัสดั้งเดิม การดำเนินการที่ซับซ้อนมากขึ้นเช่นการสร้างชุดบล็อกที่ได้รับการปรับปรุงซ้ำหรืออัลกอริทึมอื่น ๆ สามารถนำไปใช้งานได้เช่นในเมล็ด CUDA ที่กำหนดเองด้วยแบ็กเอนด์ CUDA ของ Stdgpu ที่เปิดใช้งาน: เปิดใช้งาน: เปิดใช้งาน:

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

ตัวอย่างเพิ่มเติมสามารถพบได้ในไดเรกทอรี examples

เริ่มต้น

STDGPU ต้องการ คอมไพเลอร์ C ++ 17 รวมถึงการพึ่งพาแบ็กเอนด์ที่น้อยที่สุดและสามารถสร้างและรวมเข้ากับโครงการของคุณผ่าน CMAKE ได้อย่างง่ายดาย:

• อาคารจากแหล่งกำเนิด
• การรวมเข้ากับโครงการของคุณ

แนวทางเพิ่มเติมรวมถึงการแนะนำที่ครอบคลุมเกี่ยวกับการออกแบบและ API ของ STDGPU สามารถพบได้ในเอกสาร

การบริจาค

สำหรับข้อมูลรายละเอียดเกี่ยวกับวิธีการมีส่วนร่วมให้ดูที่ส่วนที่มีส่วนร่วมในเอกสาร

ใบอนุญาต

แจกจ่ายภายใต้ใบอนุญาต Apache 2.0 ดู LICENSE สำหรับข้อมูลเพิ่มเติม

หากคุณใช้ stdgpu ในหนึ่งในโครงการของคุณโปรดอ้างอิงสิ่งพิมพ์ต่อไปนี้:

STDGPU: โครงสร้างข้อมูล STL ที่มีประสิทธิภาพบน 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: การสร้างใหม่แบบ 3 มิติแบบเรียลไทม์และสตรีมมิ่งสำหรับ telepresence สดหลายลูกค้าที่ดื่มด่ำ

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

ติดต่อ

Patrick Stotko - [email protected]