A matrix-algebraic formulation of distributed-memory maximal cardinality matching algorithms in bipartite graphs

Azad, Ariful; Buluç, Aydın

doi:10.1016/j.parco.2016.05.007

Title: A matrix-algebraic formulation of distributed-memory maximal cardinality matching algorithms in bipartite graphs

Full Record
Other Related Research

Abstract

We describe parallel algorithms for computing maximal cardinality matching in a bipartite graph on distributed-memory systems. Unlike traditional algorithms that match one vertex at a time, our algorithms process many unmatched vertices simultaneously using a matrix-algebraic formulation of maximal matching. This generic matrix-algebraic framework is used to develop three efficient maximal matching algorithms with minimal changes. The newly developed algorithms have two benefits over existing graph-based algorithms. First, unlike existing parallel algorithms, cardinality of matching obtained by the new algorithms stays constant with increasing processor counts, which is important for predictable and reproducible performance. Second, relying on bulk-synchronous matrix operations, these algorithms expose a higher degree of parallelism on distributed-memory platforms than existing graph-based algorithms. We report high-performance implementations of three maximal matching algorithms using hybrid OpenMP-MPI and evaluate the performance of these algorithm using more than 35 real and randomly generated graphs. On real instances, our algorithms achieve up to 200 × speedup on 2048 cores of a Cray XC30 supercomputer. Even higher speedups are obtained on larger synthetically generated graphs where our algorithms show good scaling on up to 16,384 cores.

Authors:

Azad, Ariful ^[1]; Buluç, Aydın ^[1]

Lawrence Berkeley National Lab. (LBNL), Berkeley, CA (United States). Computational Research Division

Publication Date:: Mon May 16 00:00:00 EDT 2016

Research Org.:: Lawrence Berkeley National Lab. (LBNL), Berkeley, CA (United States)

Sponsoring Org.:: USDOE Office of Science (SC), Advanced Scientific Computing Research (ASCR)

OSTI Identifier:: 1377506

Alternate Identifier(s):: OSTI ID: 1397980

Grant/Contract Number:: AC02-05CH11231

Resource Type:: Accepted Manuscript

Journal Name:: Parallel Computing

Additional Journal Information:: Journal Volume: 58; Journal Issue: C; Journal ID: ISSN 0167-8191

Publisher:: Elsevier

Country of Publication:: United States

Language:: English

Subject:: 97 MATHEMATICS AND COMPUTING; cardinality matching; bipartite graph; parallel algorithm; matrix-algebra

Citation Formats


                    Azad, Ariful, and Buluç, Aydın. A matrix-algebraic formulation of distributed-memory maximal cardinality matching algorithms in bipartite graphs.  United States: N. p., 2016. 
Web.  doi:10.1016/j.parco.2016.05.007.

Copy to clipboard


                    Azad, Ariful, & Buluç, Aydın. A matrix-algebraic formulation of distributed-memory maximal cardinality matching algorithms in bipartite graphs.  United States.  https://doi.org/10.1016/j.parco.2016.05.007

Copy to clipboard


                    Azad, Ariful, and Buluç, Aydın. Mon .  
"A matrix-algebraic formulation of distributed-memory maximal cardinality matching algorithms in bipartite graphs".  United States.  https://doi.org/10.1016/j.parco.2016.05.007.  https://www.osti.gov/servlets/purl/1377506.

Copy to clipboard


                    
@article{osti_1377506,

  title        = {A matrix-algebraic formulation of distributed-memory maximal cardinality matching algorithms in bipartite graphs},

  author       = {Azad, Ariful and Buluç, Aydın},

  abstractNote = {We describe parallel algorithms for computing maximal cardinality matching in a bipartite graph on distributed-memory systems. Unlike traditional algorithms that match one vertex at a time, our algorithms process many unmatched vertices simultaneously using a matrix-algebraic formulation of maximal matching. This generic matrix-algebraic framework is used to develop three efficient maximal matching algorithms with minimal changes. The newly developed algorithms have two benefits over existing graph-based algorithms. First, unlike existing parallel algorithms, cardinality of matching obtained by the new algorithms stays constant with increasing processor counts, which is important for predictable and reproducible performance. Second, relying on bulk-synchronous matrix operations, these algorithms expose a higher degree of parallelism on distributed-memory platforms than existing graph-based algorithms. We report high-performance implementations of three maximal matching algorithms using hybrid OpenMP-MPI and evaluate the performance of these algorithm using more than 35 real and randomly generated graphs. On real instances, our algorithms achieve up to 200 × speedup on 2048 cores of a Cray XC30 supercomputer. Even higher speedups are obtained on larger synthetically generated graphs where our algorithms show good scaling on up to 16,384 cores.},

  doi          = {10.1016/j.parco.2016.05.007},

  journal      = {Parallel Computing},

  number       = C,

  volume       = 58,

  place        = {United States},

  year         = {Mon May 16 00:00:00 EDT 2016},

  month        = {Mon May 16 00:00:00 EDT 2016}

}

Copy to clipboard

Journal Article:

Free Publicly Available Full Text

Accepted Manuscript (Publisher)

Accepted Manuscript (DOE)

Publisher's Version of Record

https://doi.org/10.1016/j.parco.2016.05.007

Other availability

Search WorldCat to find libraries that may hold this journal

Citation Metrics:

Cited by: 4 works

Citation information provided by
Web of Science

Save / Share:

Export Metadata

Save to My Library

Similar Records in DOE PAGES and OSTI.GOV collections:

Computing Maximum Cardinality Matchings in Parallel on Bipartite Graphs via Tree-Grafting

Journal Article Azad, Ariful ; Buluc, Aydn ; Pothen, Alex - IEEE Transactions on Parallel and Distributed Systems

It is difficult to obtain high performance when computing matchings on parallel processors because matching algorithms explicitly or implicitly search for paths in the graph, and when these paths become long, there is little concurrency. In spite of this limitation, we present a new algorithm and its shared-memory parallelization that achieves good performance and scalability in computing maximum cardinality matchings in bipartite graphs. This algorithm searches for augmenting paths via specialized breadth-first searches (BFS) from multiple source vertices, hence creating more parallelism than single source algorithms. Algorithms that employ multiple-source searches cannot discard a search tree once no augmenting pathmore »« less
https://doi.org/10.1109/TPDS.2016.2546258

Full Text Available
Multithreaded Algorithms for Maximum Matching in Bipartite Graphs

Conference Azad, Md Ariful ; Halappanavar, Mahantesh ; Rajamanickam, Siva ; ...

Abstract—We design, implement, and evaluate algorithms for computing a matching of maximum cardinality in a bipartite graph on multi-core and massively multithreaded computers. As computers with larger number of slower cores dominate the commodity processor market, the design of multithreaded algorithms to solve large matching problems becomes a necessity. Recent work on serial algorithms based on searching for augmenting paths for this problem have shown that their performance is sensitive to the order in which the vertices are processed for matching. In a multithreaded environment, imposing a serial order in which vertices are considered for matching would lead to lossmore »« less
https://doi.org/10.1109/IPDPS.2012.82
A Work-Efficient Parallel Sparse Matrix-Sparse Vector Multiplication Algorithm

Journal Article Azad, Ariful ; Buluc, Aydin - Proceedings - IEEE International Parallel and Distributed Processing Symposium (IPDPS)

We design and develop a work-efficient multithreaded algorithm for sparse matrix-sparse vector multiplication (SpMSpV) where the matrix, the input vector, and the output vector are all sparse. SpMSpV is an important primitive in the emerging GraphBLAS standard and is the workhorse of many graph algorithms including breadth-first search, bipartite graph matching, and maximal independent set. As thread counts increase, existing multithreaded SpMSpV algorithms can spend more time accessing the sparse matrix data structure than doing arithmetic. Our shared-memory parallel SpMSpV algorithm is work efficient in the sense that its total work is proportional to the number of arithmetic operations required.more »« less
Cited by 21
https://doi.org/10.1109/IPDPS.2017.76

Full Text Available
On Parallel Push-Relabel based Algorithms for Bipartite Maximum Matching

Journal Article Langguth, Johannes ; Azad, Md Ariful ; Halappanavar, Mahantesh ; ... - Parallel Computing, 40(7):289 - 308

We study multithreaded push-relabel based algorithms for computing maximum cardinality matching in bipartite graphs. Matching is a fundamental combinatorial (graph) problem with applications in a wide variety of problems in science and engineering. We are motivated by its use in the context of sparse linear solvers for computing maximum transversal of a matrix. We implement and test our algorithms on several multi-socket multicore systems and compare their performance to state-of-the-art augmenting path-based serial and parallel algorithms using a testset comprised of a wide range of real-world instances. Building on several heuristics for enhancing performance, we demonstrate good scaling for themore »« less
https://doi.org/10.1016/j.parco.2014.03.004
Data Locality Enhancement of Dynamic Simulations for Exascale Computing (Final Report)

Technical Report Shen, Xipeng

The development of modern processors exhibits two trends that complicate the optimizations of modern software. The first is the increasing sensitivity of processors' throughput to irregularities in computation. With more processors produced through a massive integration of simple cores, future systems will increasingly favor regular data-level parallel computations, but deviate from the needs of applications with complex patterns. Some evidences are already shown on Graphic Processing Units (GPU): Irregular data accesses (e.g., indirect references A[D[i]]) and conditional branches are limiting many GPU applications' performance at a level an order of magnitude lower than the peak of GPU. The second hardwaremore »« less
https://doi.org/10.2172/1576175

Full Text Available

Similar Records