Unduh KaHIP - Unduh Kode Sumber KaHIP

KaHIP

C/C++

v3.17

Unduh

Kahip v3.17

Kerangka Partisi Grafik Kahip - Karlsruhe Partisi Kualitas Tinggi.

Masalah partisi grafik meminta divisi dari simpul grafik yang diatur ke dalam blok ukuran k yang sama sehingga jumlah tepi yang berjalan di antara blok diminimalkan. Kahip adalah keluarga program partisi grafik. Ini termasuk kaffpa (partisi aliran cepat Karlsruhe), yang merupakan algoritma partisi grafik multilevel, dalam variannya yang kuat, eko dan cepat, kaffpae (Kaffpaevolutionary), yang merupakan evolusi paralel yang menggunakan Kaffpa untuk menyediakan kombinasi dan mutasi, seiring dengan baik dan mutasi, as, baik, seandainya mutasi, seandainya, asah, seiring dengan mutasi, seiring dengan baik dan mutasi, as, sewa mutasi, seiring dengan mutasi, seiring dengan baik dan mutasi seperti halnya apakah akan mutasi seperti halnya apakah akan mutasi seperti halnya apakah akan mutasi seperti apakah ada combine dan as sore, as, as, dan mutasi mutasi, as, as, dan mutasi, as, dan mutasi, as, as, as, dan mutasi, As Sungai, As Sungai, As Sungai, As Teamation, As Parallel. Selain itu, teknik khusus disertakan untuk partisi jaringan jalan (badut), untuk menghasilkan pemisah vertex dari partisi yang diberikan serta teknik yang diarahkan pada partisi yang efisien dari jejaring sosial. Berikut ini adalah gambaran tentang kerangka kerja kami:

Tinjauan Kerangka

Baru di v3.14:

Dukungan untuk Python : Kahip sekarang juga dapat digunakan dalam Python. Lihat di bawah bagaimana melakukannya.

Partisi Hierarkis : Kahip dapat menghitung partisi hierarki. Yang harus Anda lakukan adalah menentukan hierarki dan Kahip siap untuk pergi dan melakukan multiseksi seperti yang Anda tentukan.

Algoritma Pemesanan Node : Banyak aplikasi mengandalkan operasi matriks intensif waktu, seperti faktorisasi, yang dapat dipercepat secara signifikan untuk matriks jarang besar dengan menafsirkan matriks sebagai grafik jarang dan menghitung pemesanan simpul yang meminimalkan apa yang disebut pengakuan. Di sini, kami menambahkan algoritma baru untuk menghitung pengisian pengisian yang dikurangi dalam grafik.

ILP untuk kualitas yang lebih tinggi : ILP biasanya tidak skala untuk contoh besar. Kami menyesuaikan mereka dengan heuristik meningkatkan partisi yang diberikan. Kami melakukannya dengan mendefinisikan model yang jauh lebih kecil yang memungkinkan kami menggunakan pemecahan simetri dan teknik lain yang membuat pendekatan dapat diukur. Kami menyertakan ILP yang dapat digunakan sebagai langkah pasca pemrosesan untuk meningkatkan partisi berkualitas tinggi lebih jauh. Kode sekarang termasuk dalam Kahip.

TCMALLOC: Kami menambahkan kemungkinan untuk menghubungkan terhadap TCMALLOC. Bergantung pada sistem Anda, ini dapat menghasilkan keseluruhan algoritma yang lebih cepat karena menyediakan operasi malloc yang lebih cepat.

IO lebih cepat : Kami menambahkan opsi ke kaffpa (opsi --mmap_io) yang mempercepat IO file teks secara signifikan -kadang -kadang dengan urutan besarnya.

Dukungan tambahan untuk vertex dan bobot tepi dalam parhip : Kami memperluas fungsionalitas IO parhip untuk membaca grafik tertimbang dalam format METIS.

Pemetaan multiseksi global : Kami menambahkan algoritma pemetaan proses multiseksi n-to-1 global. Ini menghitung pemetaan proses yang lebih baik untuk aplikasi paralel jika informasi tentang hierarki/arsitektur sistem diketahui.

Determinism in ParHIP : we added an option to run ParHIP deterministically, ie two runs of ParHIP using the same seed will always return the same result.

Versi Bendera : Kami menambahkan opsi untuk mengeluarkan versi yang saat ini Anda gunakan, gunakan opsi --Version dari program.

Baru di v2.10:

Parhip (Parallel Berkualitas Tinggi): Teknik partisi paralel memori terdistribusi kami dirancang untuk mempartisi jaringan terstruktur secara hierarkis seperti grafik web atau jejaring sosial.

Algoritma Pemetaan: Algoritma baru kami untuk memetakan blok ke prosesor untuk meminimalkan waktu komunikasi secara keseluruhan berdasarkan partisi hierarkis dari grafik tugas dan algoritma pencarian lokal yang cepat.

Algoritma Partisi Edge: Algoritma baru kami untuk menghitung partisi tepi grafik.

Situs Proyek Utama:

https://kahip.github.io

Catatan Instalasi

Mengunduh Kahip:

Anda dapat mengunduh Kahip dengan baris perintah berikut:

 git clone https://github.com/KaHIP/KaHIP

Menyusun Kahip:

Sebelum Anda dapat memulai, Anda perlu menginstal paket perangkat lunak berikut:

Jika Anda ingin menggunakan algoritma paralel yang terkandung dalam kerangka kerja (misalnya parhip), Anda memerlukan OpenMPI (https://www.open-mpi.org/). Jika Anda tidak ingin menjalankan parhip, Anda dapat dengan mudah menyingkirkan ketergantungan ini.

Setelah Anda memasang paket, cukup ketik

 ./compile_withcmake.sh

Dalam hal ini, semua binari, perpustakaan dan header ada di folder ./deploy/

Perhatikan bahwa skrip ini mendeteksi jumlah inti yang tersedia pada mesin Anda dan menggunakan semuanya untuk proses kompilasi. Jika Anda tidak menginginkannya, atur variabel NCORES ke jumlah inti yang ingin Anda gunakan untuk kompilasi.

Atau gunakan proses pembuatan CMake standar:

 mkdir build
cd build 
cmake ../ -DCMAKE_BUILD_TYPE=Release     
make 
cd ..

Dalam hal ini, binari, perpustakaan dan header ada di folder ./build serta ./build/parallel/parallel_src/

Kami juga memberikan opsi untuk menautkan terhadap TCMALLOC. Jika Anda sudah menginstalnya, jalankan CMake dengan opsi tambahan -DUSE_TCMALLOC = ON.

Secara default program pemesanan simpul juga dikompilasi. Jika Anda telah menginstal METIS, skrip build juga menyusun program pemesanan simpul yang lebih cepat yang menggunakan pengurangan sebelum memanggil Metis nd. Perhatikan bahwa METIS membutuhkan GKLIB (https://github.com/karypislab/gklib).

Jika Anda menggunakan opsi -duse_ilp = on dan Anda telah menginstal gurobi, skrip build mengkompilasi program ILP untuk meningkatkan partisi ILP_improve yang diberikan dan pemecah ILP_exact yang tepat. Atau, Anda juga dapat meneruskan opsi ini ke ./compile_withmake.sh misalnya:

 ./compile_withcmake -DUSE_ILP=On

Kami juga memberikan opsi untuk mendukung 64 bit tepi. Untuk menggunakan ini, kompilasi kahip dengan opsi -d64bitmode = on.

Terakhir, kami memberikan opsi untuk determinisme dalam parhip, misalnya dua kali dengan benih yang sama akan memberi Anda hasil yang sama. Namun perhatikan bahwa opsi ini dapat mengurangi kualitas partisi, karena algoritma partisi awal tidak menggunakan algoritma memetika yang canggih, tetapi hanya algoritma bertingkat untuk menghitung partisi awal. Hanya gunakan opsi ini jika Anda menggunakan parhip sebagai alat. Jangan gunakan opsi ini jika Anda ingin membuat perbandingan berkualitas terhadap parhip. Untuk memanfaatkan opsi ini, jalankan

 ./compile_withcmake -DDETERMINISTIC_PARHIP=On

Menjalankan program

Untuk deskripsi format grafik (dan deskripsi yang luas dari semua program lain), harap lihat manual. Kami memberikan contoh singkat di sini.

Tinjauan Program dan Usecase

Masalah partisi default

Program dan konfigurasi ini mengambil grafik dan mempartisi lebih atau kurang berurutan. Kami mendaftar di sini Kaffpa dan Kaffpae (kerangka evolusi) dan konfigurasinya. Secara umum, konfigurasi sedemikian rupa sehingga Anda dapat menginvestasikan banyak waktu ke dalam kualitas solusi menggunakan algoritma memetika. Algoritma memetika juga dapat dijalankan secara paralel menggunakan MPI. Secara umum, semakin banyak waktu dan sumber daya yang Anda investasikan, semakin baik kualitas partisi Anda. Kami memiliki banyak pertukaran, hubungi kami jika Anda tidak yakin apa yang paling cocok untuk aplikasi Anda. Untuk deskripsi algoritma, lihat referensi yang kami daftarkan dalam manual.

Gunakan kasing	Masukan	Program
Format grafik		graph_checker
Mengevaluasi partisi		penilai
Partisi cepat	Jerat	Konfigurasi Kaffpa diatur ke cepat
Partisi yang bagus	Jerat	Konfigurasi Kaffpa diatur ke Eco
Partisi yang sangat bagus	Jerat	Konfigurasi Kaffpa diatur ke kuat
Kualitas tertinggi	Jerat	kaffpae, gunakan mpirun, batas waktu yang besar
Partisi cepat	Sosial	Konfigurasi Kaffpa diatur ke fsocial
Partisi yang bagus	Sosial	Konfigurasi Kaffpa diatur ke Esocial
Partisi yang sangat bagus	Sosial	Konfigurasi Kaffpa diatur ke SSOCIAL
Kualitas tertinggi	Sosial	kaffpae, gunakan mpirun, batas waktu besar, ssocial prakonfigurasi
Kualitas yang lebih tinggi		kaffpae, gunakan mpirun, batas waktu besar, gunakan opsi --mh_enable_tabu_search, --mh_enable_kabape

Contoh berjalan

 ./deploy/graph_checker ./examples/rgg_n_2_15_s0.graph

 ./deploy/kaffpa ./examples/rgg_n_2_15_s0.graph --k 4  --preconfiguration=strong

 mpirun -n 24 ./deploy/kaffpaE ./examples/rgg_n_2_15_s0.graph --k 4  --time_limit=3600 --mh_enable_tabu_search --mh_enable_kabapE

Partisi paralel memori terdistribusi

Sebagian besar proyek ini didistribusikan sebagai algoritma paralel memori yang dirancang untuk jaringan yang memiliki struktur kluster hierarkis seperti grafik web atau jejaring sosial. Sayangnya, partisi grafik paralel sebelumnya yang awalnya dikembangkan untuk jaringan seperti mesh yang lebih teratur tidak bekerja dengan baik untuk jaringan yang kompleks. Di sini kami membahas masalah ini dengan mempelandakan dan mengadaptasi teknik propagasi label yang awalnya dikembangkan untuk pengelompokan grafik. Dengan memperkenalkan kendala ukuran, propagasi label menjadi berlaku untuk fase pemasangan grafik bertingkat dan perbaikan. Dengan cara ini kami mengeksploitasi struktur cluster hierarkis yang ada di banyak jaringan yang kompleks. Kami memperoleh kualitas yang sangat tinggi dengan menerapkan algoritma evolusi yang sangat paralel ke grafik paling kasar. Sistem yang dihasilkan lebih diskalakan dan mencapai kualitas lebih tinggi daripada sistem canggih seperti Parmetis atau PT-Scotch.

Algoritma paralel memori terdistribusi kami dapat membaca file biner serta file format grafik METIS standar. File biner, secara umum, jauh lebih terukur daripada membaca file teks dalam aplikasi paralel. Cara untuk pergi ke sini adalah dengan mengubah file Metis menjadi file biner terlebih dahulu (akhir .bgf) dan kemudian memuat yang ini.

Gunakan kasing	Program
Partisi paralel	Parhip, Graph2Binary, Graph2Binary_External, Toolbox
Memori terdistribusi paralel, mesh	parhip dengan prakonfigs ecomesh, fastmesh, ultrafastmesh
Memori terdistribusi paralel, sosial	Parhip dengan prakonfigasi Ekososial, FASSOCIAL, ULTRAFASTSOCIAL
Konversi Metis menjadi biner	graph2binary, graph2binary_external
Mengevaluasi dan mengonversi partisi	kotak alat

Contoh berjalan

 ./deploy/graph2binary examples/rgg_n_2_15_s0.graph examples/rgg_n_2_15_s0.bgf

 mpirun -n 24 ./deploy/parhip ./examples/rgg_n_2_15_s0.graph --k 4 --preconfiguration=fastmesh

 mpirun -n 24 ./deploy/parhip ./examples/rgg_n_2_15_s0.bgf --k 4 --preconfiguration=fastmesh

Pemisah simpul

Masalah pemisah node meminta untuk mempartisi set simpul grafik menjadi tiga set A, B dan S sehingga penghapusan S memutuskan A dan B. Kami menggunakan algoritma pencarian lokal berbasis aliran dan lokal dalam kerangka kerja multilevel untuk menghitung pemisah node. Kahip juga dapat menghitung pemisah simpul. Ini dapat melakukannya dengan pemisah simpul standar (2-arah), tetapi juga dapat menghitung pemisah simpul K-Way.

Gunakan kasing	Program
Pemisah 2 arah	node_separator
Pemisah kway	Gunakan kaffpa untuk membuat k-partisi, lalu partisi_to_vertex_separator untuk membuat pemisah

Contoh berjalan

 ./deploy/node_separator examples/rgg_n_2_15_s0.graph

Pemesanan simpul

Aplikasi seperti faktorisasi dapat dipercepat secara signifikan untuk matriks jarang besar dengan menafsirkan matriks sebagai grafik yang jarang dan menghitung pemesanan simpul yang meminimalkan apa yang disebut isi. Dengan menerapkan aturan pengurangan data baru dan yang sudah ada secara mendalam sebelum diseksi bersarang, kami memperoleh kualitas yang lebih baik dan pada saat yang sama peningkatan besar dalam menjalankan waktu pada berbagai contoh. Jika METIS diinstal, skrip build juga mengkompilasi program FAST_NODE_ORDERING, yang menjalankan pengurangan sebelum menjalankan Metis untuk menghitung pemesanan. Program juga tersedia melalui perpustakaan.

Gunakan kasing	Program
Pemesanan simpul	node_ordering (dengan prakonfigurasi yang berbeda)
Pemesanan Node Cepat	fast_node_ordering

Contoh berjalan

 ./deploy/node_ordering examples/rgg_n_2_15_s0.graph

 ./deploy/fast_node_ordering examples/rgg_n_2_15_s0.graph

Partisi tepi

Perhitungan terdistribusi tepi-sentris telah muncul sebagai teknik terbaru untuk meningkatkan kekurangan algoritma Think-Like-A-Vertex pada jaringan bebas skala besar. Untuk meningkatkan paralelisme pada model ini, partisi edge-partisi tepi menjadi blok berukuran sama-telah muncul sebagai alternatif untuk partisi grafik tradisional (berbasis node). Kami menyertakan algoritma konstruksi grafik split-and-connect yang cepat dan berurutan yang menghasilkan partisi tepi berkualitas tinggi dengan cara yang dapat diskalakan. Teknik kami skala ke jaringan dengan miliaran tepi, dan berjalan secara efisien pada ribuan PE.

Gunakan kasing	Program
Partisi tepi	edge_partitioning, distribusi_edge_partitioning

Contoh berjalan

 ./deploy/edge_partitioning ./examples/rgg_n_2_15_s0.graph --k 4 --preconfiguration=fast

 mpirun -n 4 ./deploy/distributed_edge_partitioning ./examples/rgg_n_2_15_s0.bgf --k 4 --preconfiguration=fastsocial

Proses pemetaan

Pemetaan proses sadar komunikasi dan topologi adalah pendekatan yang kuat untuk mengurangi waktu komunikasi dalam aplikasi paralel dengan pola komunikasi yang diketahui pada sistem memori yang besar dan terdistribusi. Kami membahas masalah sebagai masalah penugasan kuadratik (QAP), dan memasukkan algoritma untuk membangun pemetaan proses awal ke prosesor serta algoritma pencarian lokal yang cepat untuk lebih meningkatkan pemetaan. Dengan mengeksploitasi asumsi yang biasanya berlaku untuk aplikasi dan sistem superkomputer modern seperti pola komunikasi yang jarang dan sistem komunikasi yang terorganisir secara hierarkis, kami sampai pada algoritma yang jauh lebih kuat untuk QAP khusus ini. Algoritma konstruksi bertingkat kami menggunakan teknik partisi grafik yang sangat seimbang dan secara berlebihan mengeksploitasi hierarki sistem komunikasi yang diberikan. Karena v3.0 kami memasukkan algoritma multisection global yang secara langsung mempartisi jaringan input di sepanjang hierarki yang ditentukan untuk mendapatkan pemetaan N-ke-1 dan setelah itu hubungi algoritma pemetaan 1-ke-1 untuk lebih meningkatkan pemetaan.

Gunakan kasing	Program
Pemetaan ke Jaringan Prosesor	kaffpa, dan gunakan opsi enable_mapping dengan resp. Perconfigurations
Multiseksi global	Global_MultiSection dengan resp. Perconfigurations

Contoh berjalan

 ./deploy/kaffpa examples/rgg_n_2_15_s0.graph --k 256 --preconfiguration=eco --enable_mapping --hierarchy_parameter_string=4:8:8 --distance_parameter_string=1:10:100

 ./deploy/global_multisection examples/rgg_n_2_15_s0.graph --preconfiguration=eco  --hierarchy_parameter_string=4:3:3:3 --distance_parameter_string=1:10:100:200

ILP (pemecah yang tepat) dan perbaikan ILP

Kami menyediakan ILP serta ILP untuk meningkatkan partisi yang diberikan. Kami memperluas lingkungan masalah kombinasi untuk beberapa pencarian lokal dengan menggunakan pemrograman linier integer. Ini memungkinkan kita untuk menemukan kombinasi yang lebih kompleks dan karenanya untuk lebih meningkatkan solusi. Namun, di luar kotak yang ILP untuk masalah biasanya tidak skala input besar, khususnya karena masalah partisi grafik memiliki jumlah simetri yang sangat besar - diberikan partisi grafik, setiap permutasi ID blok memberikan solusi yang memiliki tujuan dan keseimbangan yang sama. Kami mendefinisikan grafik yang jauh lebih kecil, yang disebut model, dan menyelesaikan masalah partisi grafik pada model untuk optimalitas oleh program linear integer. Selain hal -hal lain, model ini memungkinkan kita untuk menggunakan pemecahan simetri, yang memungkinkan kita untuk skala ke input yang jauh lebih besar. Untuk mengkompilasi program -program ini, Anda perlu menjalankan cmake dalam proses pembuatan di atas sebagai cmake ../ -dcmake_build_type = rilis -duse_ilp = on atau run ./compile_withcmake -duse_ilp = on.

Gunakan kasing	Program
Pemecah yang tepat	ILP_EXACT
Peningkatan melalui ILP	ILP_Improve

Contoh berjalan

 ./deploy/ilp_improve ./examples/rgg_n_2_15_s0.graph --k 4 --input_partition=tmppartition4

 ./deploy/ilp_exact ./examples/example_weighted.graph  --k 3

Menghubungkan Perpustakaan Kahip

Kahip juga menawarkan perpustakaan dan antarmuka untuk menautkan algoritma langsung ke kode Anda. Kami menjelaskan detail antarmuka dalam manual. Di bawah ini kami mencantumkan contoh program yang menautkan Perpustakaan Kahip. Contoh ini juga dapat ditemukan di misc/example_library_call/.

# include < iostream >
# include < sstream >

# include " kaHIP_interface.h "


int main ( int argn, char **argv) {

        std::cout <<  " partitioning graph from the manual "  << std::endl;

        int n            = 5 ;
        int * xadj        = new int [ 6 ];
        xadj[ 0 ] = 0 ; xadj[ 1 ] = 2 ; xadj[ 2 ] = 5 ; xadj[ 3 ] = 7 ; xadj[ 4 ] = 9 ; xadj[ 5 ] = 12 ;

        int * adjncy      = new int [ 12 ];
        adjncy[ 0 ]  = 1 ; adjncy[ 1 ]  = 4 ; adjncy[ 2 ]  = 0 ; adjncy[ 3 ]  = 2 ; adjncy[ 4 ]  = 4 ; adjncy[ 5 ]  = 1 ; 
        adjncy[ 6 ]  = 3 ; adjncy[ 7 ]  = 2 ; adjncy[ 8 ]  = 4 ; adjncy[ 9 ]  = 0 ; adjncy[ 10 ] = 1 ; adjncy[ 11 ] = 3 ; 
        
        double imbalance = 0.03 ;
        int * part        = new int [n];
        int edge_cut     = 0 ;
        int nparts       = 2 ;
        int * vwgt        = NULL ;
        int * adjcwgt     = NULL ;

        kaffpa (&n, vwgt, xadj, adjcwgt, adjncy, &nparts, &imbalance, false , 0 , ECO, & edge_cut, part);

        std::cout <<  " edge cut " <<  edge_cut  << std::endl;
}

Menggunakan Kahip di Python

Kahip juga dapat digunakan dalam Python. Jika Anda ingin menggunakannya di Python First Run

 python3 -m pip install pybind11

Lalu jalankan

 ./compile_withcmake.sh BUILDPYTHONMODULE

untuk membangun model Python. Ini akan membangun modul python dan juga memberi contoh callkahipfrompython.py ke dalam folder Deploy. Anda dapat menjalankan ini dengan mengetik berikut di folder Deploy:

 python3 callkahipfrompython.py

Perhatikan bahwa kami hanya memberikan dukungan awal, yaitu Anda mungkin perlu mengubah beberapa jalur ke Python di dalam file compile_withcmake. Contoh juga dapat ditemukan di bawah:

 import kahip ;

#build adjacency array representation of the graph
xadj           = [ 0 , 2 , 5 , 7 , 9 , 12 ];
adjncy         = [ 1 , 4 , 0 , 2 , 4 , 1 , 3 , 2 , 4 , 0 , 1 , 3 ];
vwgt           = [ 1 , 1 , 1 , 1 , 1 ]
adjcwgt        = [ 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 ]
supress_output = 0
imbalance      = 0.03
nblocks        = 2 
seed           = 0

# set mode 
#const int FAST           = 0;
#const int ECO            = 1;
#const int STRONG         = 2;
#const int FASTSOCIAL     = 3;
#const int ECOSOCIAL      = 4;
#const int STRONGSOCIAL   = 5;
mode = 0 

edgecut , blocks = kahip . kaffpa ( vwgt , xadj , adjcwgt , 
                              adjncy ,  nblocks , imbalance , 
                              supress_output , seed , mode )

print ( edgecut )
print ( blocks )

Lisensi

Program ini dilisensikan di bawah lisensi MIT. Jika Anda mempublikasikan hasil menggunakan algoritma kami, silakan akui karya kami dengan mengutip makalah berikut:

 @inproceedings{sandersschulz2013,
             AUTHOR = {Sanders, Peter and Schulz, Christian},
             TITLE = {{Think Locally, Act Globally: Highly Balanced Graph Partitioning}},
             BOOKTITLE = {Proceedings of the 12th International Symposium on Experimental Algorithms (SEA'13)},
             SERIES = {LNCS},
             PUBLISHER = {Springer},
             YEAR = {2013},
             VOLUME = {7933},
             PAGES = {164--175}
}

Jika Anda menggunakan parhip partisi paralel kami, silakan juga mengutip makalah berikut:

 @inproceedings{meyerhenkesandersschulz2017,
             AUTHOR = {Meyerhenke, Henning and Sanders, Peter and Schulz, Christian},
             TITLE = {{Parallel Graph Partitioning for Complex Networks}},
             JOURNAL = {IEEE Transactions on Parallel and Distributed Systems (TPDS)},
             VOLUME = {28},
             NUMBER = {9},
             PAGES = {2625--2638},
             YEAR = {2017}
}

Jika Anda menggunakan algoritma pemetaan, silakan juga mengutip kertas berikut:

 @inproceedings{schulztraeff2017,
             AUTHOR = {Schulz, Christian and Träff, Jesper Larsson},
             TITLE = {{Better Process Mapping and Sparse Quadratic Assignment}},
             BOOKTITLE = {Proceedings of the 16th International Symposium on Experimental Algorithms (SEA'17)},
             PUBLISHER = {Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik},
             VOLUME = {75},
             SERIES = {LIPIcs},
             PAGES = {4:1--4:15},
             YEAR = {2017}
}

Jika Anda menggunakan algoritma partisi edge, silakan juga mengutip kertas berikut:

 @inproceedings{edgepartitioning2019,
             AUTHOR = {Schlag, Sebastian and Schulz, Christian and Seemaier, Daniel and Strash, Darren},
             TITLE = {{Scalable Edge Partitioning}},
             BOOKTITLE = {Proceedings of the 21th Workshop on Algorithm Engineering and Experimentation (ALENEX)},
             PUBLISHER = {SIAM},
             PAGES = {211--225},
             YEAR = {2019}
}

Jika Anda menggunakan algoritma pemesanan simpul, silakan juga mengutip kertas berikut:

 @article{DBLP:journals/corr/abs-2004-11315,
  author    = {Wolfgang Ost and
               Christian Schulz and
               Darren Strash},
  title     = {Engineering Data Reduction for Nested Dissection},
  journal   = {CoRR},
  volume    = {abs/2004.11315},
  year      = {2020},
  url       = {https://arxiv.org/abs/2004.11315},
  archivePrefix = {arXiv},
  eprint    = {2004.11315},
  timestamp = {Tue, 28 Apr 2020 16:10:02 +0200},
  biburl    = {https://dblp.org/rec/journals/corr/abs-2004-11315.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

Jika Anda menggunakan algoritma ILP untuk meningkatkan partisi, silakan juga mengutip kertas berikut:

 @inproceedings{DBLP:conf/wea/HenzingerN018,
  author    = {Alexandra Henzinger and
               Alexander Noe and
               Christian Schulz},
  title     = {ILP-based Local Search for Graph Partitioning},
  booktitle = {17th International Symposium on Experimental Algorithms, {SEA} 2018},
  pages     = {4:1--4:15},
  year      = {2018},
  url       = {https://doi.org/10.4230/LIPIcs.SEA.2018.4},
  doi       = {10.4230/LIPIcs.SEA.2018.4},
  series    = {LIPIcs},
  volume    = {103},
  publisher = {Schloss Dagstuhl - Leibniz-Zentrum f{"{u}}r Informatik}
}