research-article

A High-Quality and Fast Maximal Independent Set Implementation for GPUs

Authors:

Martin Burtscher,

Jayadharini Jaiganesh,

Evan PowersAuthors Info & Claims

ACM Transactions on Parallel Computing (TOPC), Volume 5, Issue 2

Article No.: 8, Pages 1 - 27

https://doi.org/10.1145/3291525

Published: 08 December 2018 Publication History

Abstract

Computing a maximal independent set is an important step in many parallel graph algorithms. This article introduces ECL-MIS, a maximal independent set implementation that works well on GPUs. It includes key optimizations to speed up computation, reduce the memory footprint, and increase the set size. Its CUDA implementation requires fewer than 30 kernel statements, runs asynchronously, and produces a deterministic result. It outperforms the maximal independent set implementations of Pannotia, CUSP, and IrGL on each of the 16 tested graphs of various types and sizes. On a Titan X GPU, ECL-MIS is between 3.9 and 100 times faster (11.5 times, on average). ECL-MIS running on the GPU is also faster than the parallel CPU codes Ligra, Ligra+, and PBBS running on 20 Xeon cores, which it outperforms by 4.1 times, on average. At the same time, ECL-MIS produces maximal independent sets that are up to 52% larger (over 10%, on average) compared to these preexisting CPU and GPU implementations. Whereas these codes produce maximal independent sets that are, on average, about 15% smaller than the largest possible such sets, ECL-MIS sets are less than 6% smaller than the maximum independent sets.

References

[1]

Mark F. Adams. 1998. A parallel maximal independent set algorithm. In Proceedings of the 5th Copper Mountain Conference on Iterative Methods. http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.40.8968.

Digital Library

[2]

Takuya Akiba and Yoichi Iwata. 2016. Branch-and-reduce exponential/FPT algorithms in practice: a case study of vertex cover. In Theoretical Computer Science 609, 1 (2016), 211--225.

Digital Library

[3]

Guy E. Blelloch, Jeremy T. Fineman, and Julian Shun. 2012. Greedy sequential maximal independent set and matching are parallel on average. In Proceedings of the 24th Annual ACM Symposium on Parallelism in Algorithms and Architectures (SPAA’12). ACM, New York, NY, 308--317.

Digital Library

[4]

Lijun Chang, Wei Li, and Wenjie Zhang. 2017. Computing a near-maximum independent set in linear time by reducing-peeling. In Proceedings of the 2017 ACM International Conference on Management of Data (SIGMOD’17). ACM, New York, NY, 1181--1196.

Digital Library

[5]

Shuai Che, Bradford M. Beckmann, Steven K. Reinhardt, Kevin Skadron. 2013. Pannotia; Understanding irregular GPGPU graph applications. In IEEE International Symposium on Workload Characterization (IISWC’13). IEEE, Portland, OR, 185--195.

[6]

Edmond Chow, Robert D. Falgout, Jonathan J. Hu, Raymond S. Tuminaro, and Ulrike Meier Yang. 2006. A survey of parallelization techniques for multigrid solvers. Parallel Processing for Scientific Computing 20 (2006), 179--201.

[7]

Jakob Dahlum, Sebastian Lamm, Peter Sanders, Christian Schulz, Darren Strash, and Renato F. Werneck. 2016. Accelerating local search for the maximum independent set problem. In Experimental Algorithms (SEA’16). Lecture Notes in Computer Science, Vol. 9685, A. Goldberg, A. Kulikov (Eds.). Springer.

Digital Library

[8]

Steven Dalton, Nathan Bell, Luke Olson, and Michael Garland. 2014. CUSP: Generic parallel algorithms for sparse matrix and graph computations. Version 0.5.0. http://cusplibrary.github.io/.

[9]

Camil Demetrescu. 2010. DIMACS9 (June 2010). Retrieved June 6, 2017 from http://www.dis.uniroma1.it/challenge9/download.shtml.

[10]

Geoffrey C. Fox, Mark A. Johnson, Gregory A. Lyzenga, Steve W. Otto, John K. Salmon, and David W. Walker. 1988. Solving Problems on Concurrent Processors, General Techniques and Regular Problems, Vol. 1. Prentice-Hall, Inc., Upper Saddle, NJ.

Digital Library

[11]

Mohsen Ghaffari. 2016. An improved distributed algorithm for maximal independent set. In Proceedings of the 27th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA’16), Robert Kraughgamer (Ed.). SIAM, Philadelphia, PA, 270--277.

Digital Library

[12]

Git Hub. 2016. Ligra. Retrieved November 15, 2018 from https://github.com/jshun/ligra.

[13]

Git Hub. 2017. Pannotia. Retrieved November 15, 2018 from https://github.com/pannotia/pannotia.

[14]

Kshitij Gupta, Jeff A. Stuart, and John D. Owens. 2012. A study of persistent threads style GPU programming for GPGPU workloads. In Innovative Parallel Computing (InPar’12). San Jose, CA, 1--14.

[15]

William Hasenplaugh, Tim Kaler, Tao B. Schardl, and Charles E. Leiserson. 2014. Ordering Heuristics for Parallel Graph Coloring. In Proceedings of the 26th ACM Symposium on Parallelism in Algorithms and Architectures (SPAA’14). ACM, New York, NY, 166--177. http://doi.acm.org/10.1145/2612669.2612697

Digital Library

[16]

Benoît Hudson, Gary L. Miller, and Todd Phillips. 2007. Sparse parallel Delaunay mesh refinement. In Proceedings of the 19th Annual ACM Symposium on Parallel Algorithms and Architectures (SPAA’07). ACM, New York, NY, 339--347.

Digital Library

[17]

ISS. 2014. Galois. Retrieved November 15, 2018 from http://iss.ices.utexas.edu/?p=projects/galois/download.

[18]

Yan Jin and Jin-Kao Hao. 2015. General swap-based multiple neighborhood tabu search for the maximum independent set problem. Engineering Applications of Artificial Intelligence 37 (2015), 20--33.

[19]

KaMIS. 2017. Retrieved November 15, 2018 from http://algo2.iti.kit.edu/kamis/.

[20]

Richard M. Karp and Avi Wigderson. 1984. A fast parallel algorithm for the maximal independent set problem. In Proceedings of the 16th Annual ACM Symposium on Theory of Computing (STOC’84). ACM, New York, NY, 266--272.

Digital Library

[21]

Sebastian Lamm, Peter Sanders, Christian Schulz, Darren Strash, and Renato F. Werneck. 2017. Finding near-optimal independent sets at scale. Journal of Heuristics 23, 4 (2017), 207--229.

Digital Library

[22]

Michael Luby. 1985. A simple parallel algorithm for the maximal independent set problem. In Proceedings of the 17th Annual ACM Symposium on Theory of Computing (STOC’85). ACM, New York, NY, 1--10.

Digital Library

[23]

Michael Luby. 1986. A simple parallel algorithm for the maximal independent set problem. SIAM Journal on Computing 15, 4 (1986), 1036--1053.

Digital Library

[24]

Mario Méndez-Lojo, Donald Nguyen, Dimitrios Prountzos, Xin Sui, M. Amber Hassaan, Milind Kulkarni, Martin Burtscher, and Keshav Pingali. 2010. Structure-driven optimizations for amorphous data-parallel programs. In Proceedings of the 15th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP’10). ACM, New York, NY, 3--14.

Digital Library

[25]

Rupesh Nasre, Martin Burtscher, and Keshav Pingali. 2013. Atomic-free irregular computations on GPUs. In Proceedings of the 6th Workshop on General Purpose Processor Using Graphics Processing Units (GPGPU-6), John Cavazos, Xiang Gong, and David Kaeli (Eds.). ACM, New York, NY, 96--107.

Digital Library

[26]

NearLinear. Retrieved November 15, 2018 from https://github.com/LijunChang/Near-Maximum-Independent-Set.

[27]

NVIDIA. 2017. CUSP. Retrieved November 15, 2018 from https://developer.nvidia.com/cusp.

[28]

NVIDIA. 2017. THRUST. Retrieved November 15, 2018 from https://developer.nvidia.com/thrust.

[29]

Sreepathi Pai and Keshav Pingali. 2016. A compiler for throughput optimization of graph algorithms on GPUs. SIGPLAN Not. 51, 10 (2016), 1--19.

Digital Library

[30]

PBBS. 2014. Retrieved November 15, 2018 from http://www.cs.cmu.edu/∼pbbs/.

[31]

Jonathan R. Shewchuk. 2002. Delaunay refinement algorithms for triangular mesh generation. Computational Geometry: Theory and Applications 22, 1-3 (2002), 21--74.

Digital Library

[32]

SNAP. Retrieved November 15, 2018 from https://snap.stanford.edu/data/.

[33]

Sparse Matrix Collection. Retrieved November 15, 2018 from https://www.cise.ufl.edu/research/sparse/matrices/.

[34]

TEPS. Retrieved November 15, 2018 from http://www.graph500.org/specifications#sec-8_2.

[35]

Leslie G. Valiant. 1982. Parallel computation. In Proceedings of the 7th IBM Symposium on Mathematical Foundations of Computer Science. 171--189.

Cited By

Baumann YKyng RAgrawal KPetrank E(2024)A Framework for Parallelizing Approximate Gaussian EliminationProceedings of the 36th ACM Symposium on Parallelism in Algorithms and Architectures10.1145/3626183.3659987(195-206)Online publication date: 17-Jun-2024
https://dl.acm.org/doi/10.1145/3626183.3659987
Ma LChen KShao MWang MYoon B(2023)On the Maximal Independent Sets of k-mers with the Edit DistanceProceedings of the 14th ACM International Conference on Bioinformatics, Computational Biology, and Health Informatics10.1145/3584371.3612982(1-6)Online publication date: 3-Sep-2023
https://dl.acm.org/doi/10.1145/3584371.3612982
Wang XWen DZhang WZhang YQin L(2023)Distributed Near-Maximum Independent Set Maintenance over Large-scale Dynamic Graphs2023 IEEE 39th International Conference on Data Engineering (ICDE)10.1109/ICDE55515.2023.00195(2538-2550)Online publication date: Apr-2023
https://doi.org/10.1109/ICDE55515.2023.00195
Show More Cited By

Index Terms

A High-Quality and Fast Maximal Independent Set Implementation for GPUs
1. Computing methodologies
  1. Parallel computing methodologies
    1. Parallel algorithms
      1. Massively parallel algorithms

Recommendations

A GEMM interface and implementation on NVIDIA GPUs for multiple small matrices

We present an interface and an implementation of the General Matrix Multiply (GEMM) routine for multiple small matrices processed simultaneously on NVIDIA graphics processing units (GPUs). We focus on matrix sizes under 16. The implementation can be ...
A performance study of general-purpose applications on graphics processors using CUDA

Graphics processors (GPUs) provide a vast number of simple, data-parallel, deeply multithreaded cores and high memory bandwidths. GPU architectures are becoming increasingly programmable, offering the potential for dramatic speedups for a variety of ...
Performance Tuning of Matrix Multiplication in OpenCL on Different GPUs and CPUs
SCC '12: Proceedings of the 2012 SC Companion: High Performance Computing, Networking Storage and Analysis

OpenCL (Open Computing Language) is a framework for general-purpose parallel programming. Programs written in OpenCL are functionally portable across multiple processors including CPUs, GPUs, and also FPGAs. Using an auto-tuning technique makes ...

Comments

Information & Contributors

Information

Published In

cover image ACM Transactions on Parallel Computing

ACM Transactions on Parallel Computing Volume 5, Issue 2

June 2018

113 pages

ISSN:2329-4949

EISSN:2329-4957

DOI:10.1145/3299751

Editor:
David Bader
Georgia Institute of Technology, USA

Issue’s Table of Contents

Copyright © 2018 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 08 December 2018

Accepted: 01 March 2018

Revised: 01 March 2018

Received: 01 November 2017

Published in TOPC Volume 5, Issue 2

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article
Research
Refereed

Funding Sources

NVIDIA Corporation
U.S. National Science Foundation

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

9
Total Citations
View Citations
194
Total Downloads

Downloads (Last 12 months)25
Downloads (Last 6 weeks)1

Reflects downloads up to 10 Nov 2024

Other Metrics

View Author Metrics

Citations

Cited By

Baumann YKyng RAgrawal KPetrank E(2024)A Framework for Parallelizing Approximate Gaussian EliminationProceedings of the 36th ACM Symposium on Parallelism in Algorithms and Architectures10.1145/3626183.3659987(195-206)Online publication date: 17-Jun-2024
https://dl.acm.org/doi/10.1145/3626183.3659987
Ma LChen KShao MWang MYoon B(2023)On the Maximal Independent Sets of k-mers with the Edit DistanceProceedings of the 14th ACM International Conference on Bioinformatics, Computational Biology, and Health Informatics10.1145/3584371.3612982(1-6)Online publication date: 3-Sep-2023
https://dl.acm.org/doi/10.1145/3584371.3612982
Wang XWen DZhang WZhang YQin L(2023)Distributed Near-Maximum Independent Set Maintenance over Large-scale Dynamic Graphs2023 IEEE 39th International Conference on Data Engineering (ICDE)10.1109/ICDE55515.2023.00195(2538-2550)Online publication date: Apr-2023
https://doi.org/10.1109/ICDE55515.2023.00195
Fallin ABurtscher M(2022)Reducing Memory-Bus Energy Consumption of GPUs via Software-Based Bit-Flip Minimization2022 IEEE/ACM Workshop on Memory Centric High Performance Computing (MCHPC)10.1109/MCHPC56545.2022.00008(21-29)Online publication date: Nov-2022
https://doi.org/10.1109/MCHPC56545.2022.00008
Kelley BRajamanickam S(2022)Parallel, Portable Algorithms for Distance-2 Maximal Independent Set and Graph Coarsening2022 IEEE International Parallel and Distributed Processing Symposium (IPDPS)10.1109/IPDPS53621.2022.00035(280-290)Online publication date: May-2022
https://doi.org/10.1109/IPDPS53621.2022.00035
Yamout PBarada KJaljuli AMouawad AEl Hajj I(2022)Parallel Vertex Cover Algorithms on GPUs2022 IEEE International Parallel and Distributed Processing Symposium (IPDPS)10.1109/IPDPS53621.2022.00028(201-211)Online publication date: May-2022
https://doi.org/10.1109/IPDPS53621.2022.00028
Azami NBurtscher M(2022)Compressed In-memory Graphs for Accelerating GPU-based Analytics2022 IEEE/ACM Workshop on Irregular Applications: Architectures and Algorithms (IA3)10.1109/IA356718.2022.00011(32-40)Online publication date: Nov-2022
https://doi.org/10.1109/IA356718.2022.00011
Imanaga TNakano KYasudo RIto YKawamata YKatsuki RTabata YYazane THamano K(2021)Simple iterative trial search for the maximum independent set problem optimized for the GPUsConcurrency and Computation: Practice and Experience10.1002/cpe.668135:14Online publication date: 8-Nov-2021
https://doi.org/10.1002/cpe.6681
Imanaga TNakano KTao MYasudo RIto YKawamata YKatsuki RTabata YYazane THamano K(2020)Efficient GPU Implementation for Solving the Maximum Independent Set Problem2020 Eighth International Symposium on Computing and Networking (CANDAR)10.1109/CANDAR51075.2020.00012(29-38)Online publication date: Nov-2020
https://doi.org/10.1109/CANDAR51075.2020.00012

View Options

Get Access

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Article

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Media

Figures

Other

Tables

View Issue’s Table of Contents