[Paper Review] Parallel Algorithms for Butterfly Computations

Jessica Shi, Julian Shun|arXiv (Cornell University)|Jul 19, 2019

Advanced Graph Theory Research4 citations

TL;DR

This paper introduces ParButterfly, a modular framework for efficient parallel butterfly computation in bipartite graphs, using wedge aggregation via sorting, hashing, histogramming, or batching, combined with vertex ranking strategies. It achieves up to 13.6x speedup over the fastest sequential algorithms and up to 38.5x self-relative speedup on 48-core systems, significantly outperforming general subgraph counting methods and prior parallel implementations.

ABSTRACT

Butterflies are the smallest non-trivial subgraph in bipartite graphs, and therefore having efficient computations for analyzing them is crucial to improving the quality of certain applications on bipartite graphs. In this paper, we design a framework called ParButterfly that contains new parallel algorithms for the following problems on processing butterflies: global counting, per-vertex counting, per-edge counting, tip decomposition (vertex peeling), and wing decomposition (edge peeling). The main component of these algorithms is aggregating wedges incident on subsets of vertices, and our framework supports different methods for wedge aggregation, including sorting, hashing, histogramming, and batching. In addition, ParButterfly supports different ways of ranking the vertices to speed up counting, including side ordering, approximate and exact degree ordering, and approximate and exact complement coreness ordering. For counting, ParButterfly also supports both exact computation as well as approximate computation via graph sparsification. We prove strong theoretical guarantees on the work and span of the algorithms in ParButterfly. We perform a comprehensive evaluation of all of the algorithms in ParButterfly on a collection of real-world bipartite graphs using a 48-core machine. Our counting algorithms obtain significant parallel speedup, outperforming the fastest sequential algorithms by up to 13.6x with a self-relative speedup of up to 38.5x. Compared to general subgraph counting solutions, we are orders of magnitude faster. Our peeling algorithms achieve self-relative speedups of up to 10.7x and outperform the fastest sequential baseline by up to several orders of magnitude.

Motivation & Objective

• Address the lack of efficient parallel algorithms for butterfly computations in large-scale bipartite graphs, which are critical for applications like link spam detection and document clustering.
• Design a modular framework that supports multiple aggregation strategies (sorting, hashing, histogramming, batching) and vertex ranking methods (degree, coreness, side-ordering) to optimize performance.
• Enable both exact and approximate butterfly counting via graph sparsification, and integrate cache-optimized wedge retrieval for improved memory efficiency.
• Develop parallel peeling algorithms (tip and wing decomposition) that hierarchically extract dense subgraphs, analogous to k-core decomposition in unipartite graphs.
• Establish strong theoretical guarantees on work and span for all algorithms, ensuring correctness and scalability on shared-memory multicore architectures.

Proposed method

• Aggregate wedges (2-paths) incident on vertex pairs using four parallel aggregation techniques: sorting, hashing, histogramming, and batching to enable efficient butterfly counting.
• Apply vertex ranking via degree ordering (exact and approximate) and complement coreness ordering (exact and approximate) to prioritize high-impact wedges and reduce redundant computation.
• Integrate graph sparsification techniques from Sanei-Mehri et al. [53] to enable fast approximate butterfly counting with provable error bounds.
• Leverage the Cilk scheduler for task parallelism in wedge aggregation and peeling iterations, ensuring load balancing and low overhead.
• Implement parallel tip (vertex) and wing (edge) peeling algorithms that iteratively remove vertices/edges with minimal butterfly counts, updating counts in parallel across iterations.
• Incorporate a cache-optimized wedge retrieval strategy from Wang et al. [65] to reduce memory access latency during wedge enumeration.

Experimental results

Research questions

• RQ1 Can efficient parallel algorithms be designed for global, per-vertex, and per-edge butterfly counting in bipartite graphs using modular, composable components?
• RQ2 How do different wedge aggregation strategies (sorting, hashing, histogramming, batching) impact performance and scalability in shared-memory parallel systems?
• RQ3 To what extent can vertex ranking via degree or coreness ordering reduce the computational work in butterfly counting?
• RQ4 Can approximate butterfly counting via graph sparsification maintain accuracy while achieving significant speedups in large-scale graphs?
• RQ5 How do parallel peeling algorithms for tip and wing decomposition compare in performance and scalability to sequential baselines and existing distributed solutions?

Key findings

• ParButterfly’s counting algorithms achieve up to 13.6x speedup over the fastest sequential baseline and up to 38.5x self-relative speedup on a 48-core machine, demonstrating strong parallel scalability.
• The framework outperforms general subgraph counting solutions by orders of magnitude, particularly on large real-world bipartite graphs such as the Delicious tag-item graph.
• Peeling algorithms achieve up to 10.7x self-relative speedup and outperform the fastest sequential baseline by several orders of magnitude, confirming their effectiveness for dense subgraph discovery.
• The combination of vertex ranking (especially degree and complement coreness ordering) with efficient aggregation methods significantly reduces running time across all test graphs.
• Graph sparsification enables fast approximate counting with minimal accuracy loss, making it viable for interactive analysis on massive graphs.
• The integration of cache-optimized wedge retrieval from Wang et al. [65] further improves performance, especially on memory-bound workloads.