gunrock

Gunrock: CUDA/C ++ GPU Graph Analytics

Contoh	Template Proyek	Dokumentasi	Tindakan GitHub

Gunrock ¹ adalah perpustakaan CUDA untuk pemrosesan grafik yang dirancang khusus untuk GPU. Menggunakan abstraksi data -sindrik , bulk-sinkron/asinkron , yang berfokus pada operasi pada vertex atau perbatasan tepi. Gunrock mencapai keseimbangan antara kinerja dan ekspresi dengan menggabungkan primitif komputasi GPU berkinerja tinggi dan strategi optimasi, terutama di bidang penyeimbangan beban berbutir halus, dengan model pemrograman tingkat tinggi yang memungkinkan pemrogram untuk dengan cepat mengembangkan primitif grafik baru yang skala dari satu ke banyak GPU pada node dengan ukuran kode kecil dan program GPU minimal.

Cabang	Tujuan	Versi	Status
main	Cabang default, porting dari gunrock/essentials , berfungsi sebagai cabang rilis resmi.	$ geq $ 2.xx	Aktif
develop	Cabang Fitur Pengembangan, porting dari gunrock/essentials .	$ geq $ 2.xx	Aktif
master	Cabang rilis sebelumnya untuk antarmuka gunrock/gunrock versi 1.xx , mempertahankan semua sejarah komit.	$ leq $ 1.xx	Tercerahkan
dev	Cabang Pengembangan Sebelumnya untuk gunrock/gunrock . Semua perubahan sekarang digabungkan dalam master .	$ leq $ 1.xx	Tercerahkan

Panduan Mulai Cepat

Sebelum membangun Gunrock, pastikan Anda memiliki CUDA TOOLKIT ² yang diinstal pada sistem Anda. Ketergantungan eksternal lainnya seperti NVIDIA/thrust , NVIDIA/cub , dll. Secara otomatis diambil menggunakan cmake .

git clone https://github.com/gunrock/gunrock.git
cd gunrock
mkdir build && cd build
cmake .. 
make sssp # or for all algorithms, use: make -j$(nproc)
bin/sssp ../datasets/chesapeake/chesapeake.mtx

Menerapkan algoritma grafik

Untuk penjelasan terperinci, silakan lihat dokumentasi lengkapnya. Contoh berikut menunjukkan API sederhana menggunakan model pemrograman data-sentris-sentris, kami, kami menerapkan pencarian yang luas di GPU. Contoh ini melewatkan fase pengaturan untuk membuat struct problem_t dan enactor_t dan melompat langsung ke algoritma yang sebenarnya.

Pertama-tama kami menyiapkan perbatasan kami dengan titik sumber awal untuk memulai traversal BFS berbasis push. f->push_back(source) sederhana menempatkan simpul awal yang akan kita gunakan untuk iterasi pertama kita.

 void prepare_frontier ( frontier_t * f,
                      gcuda:: multi_context_t & context) override {
  auto P = this -> get_problem ();
  f-> push_back (P-> param . single_source );
}

Kami kemudian memulai loop berulang kami, yang berulang sampai kondisi konvergensi telah dipenuhi. Jika tidak ada kondisi yang ditentukan, loop konvergen ketika perbatasan kosong.

 void loop (gcuda:: multi_context_t & context) override {
  auto E = this -> get_enactor ();   // Pointer to enactor interface.
  auto P = this -> get_problem ();   // Pointer to problem (data) interface.
  auto G = P-> get_graph ();        // Graph that we are processing.

  auto single_source = P-> param . single_source ;  // Initial source node.
  auto distances = P-> result . distances ;         // Distances array for BFS.
  auto visited = P-> visited . data (). get ();       // Visited map.
  auto iteration = this -> iteration ;             // Iteration we are on.

  // Following lambda expression is applied on every source,
  // neighbor, edge, weight tuple during the traversal.
  // Our intent here is to find and update the minimum distance when found.
  // And return which neighbor goes in the output frontier after traversal.
  auto search = [=] __host__ __device__ (
                      vertex_t const & source,    // ... source
                      vertex_t const & neighbor,  // neighbor
                      edge_t const & edge,        // edge
                      weight_t const & weight     // weight (tuple).
                      ) -> bool {
    auto old_distance =
      math::atomic::min (&distances[neighbor], iteration + 1 );
    return (iteration + 1 < old_distance);
  };

  // Execute advance operator on the search lambda expression.
  // Uses load_balance_t::block_mapped algorithm (try others for perf. tuning.)
  operators::advance::execute<operators:: load_balance_t ::block_mapped>(
    G, E, search, context);
}

Sertakan/Gunrock/Algoritma/BFS.HXX

Cara mengutip tembak & penting

Terima kasih telah mengutip pekerjaan kami.

 @article { Wang:2017:GGG ,
  author =	 { Yangzihao Wang and Yuechao Pan and Andrew Davidson
                  and Yuduo Wu and Carl Yang and Leyuan Wang and
                  Muhammad Osama and Chenshan Yuan and Weitang Liu and
                  Andy T. Riffel and John D. Owens } ,
  title =	 { {G}unrock: {GPU} Graph Analytics } ,
  journal =	 { ACM Transactions on Parallel Computing } ,
  year =	 2017 ,
  volume =	 4 ,
  number =	 1 ,
  month =	 aug,
  pages =	 { 3:1--3:49 } ,
  doi =		 { 10.1145/3108140 } ,
  ee =		 { http://arxiv.org/abs/1701.01170 } ,
  acmauthorize = { https://dl.acm.org/doi/10.1145/3108140?cid=81100458295 } ,
  url =		 { http://escholarship.org/uc/item/9gj6r1dj } ,
  code =	 { https://github.com/gunrock/gunrock } ,
  ucdcite =	 { a115 } ,
}

 @InProceedings { Osama:2022:EOP ,
  author =	 { Muhammad Osama and Serban D. Porumbescu and John D. Owens } ,
  title =	 { Essentials of Parallel Graph Analytics } ,
  booktitle =	 { Proceedings of the Workshop on Graphs,
                  Architectures, Programming, and Learning } ,
  year =	 2022 ,
  series =	 { GrAPL 2022 } ,
  month =	 may,
  pages =	 { 314--317 } ,
  doi =		 { 10.1109/IPDPSW55747.2022.00061 } ,
  url =          { https://escholarship.org/uc/item/2p19z28q } ,
}

Hak Cipta & Lisensi

Gunrock adalah hak cipta Bupati Universitas California. Perpustakaan, contoh, dan semua kode sumber dirilis di bawah Apache 2.0.

Catatan kaki

1. Repositori ini telah dipindahkan dari https://github.com/gunrock/essentials dan sejarah sebelumnya dilestarikan dengan tag dan di bawah Cabang master . Baca lebih lanjut tentang Gunrock dan Essentials in Our Vision Paper: Essentials of Parallel Graph Analytics. ↩

2. Direkomendasikan CUDA V11.5.1 atau lebih tinggi karena dukungan untuk alokasi memori yang dipesan aliran. ↩