[Paper Review] Parallel Batch-Dynamic $k$-Clique Counting

Laxman Dhulipala, Quanquan C. Liu+2 more|arXiv (Cornell University)|Mar 30, 2020

Complexity and Algorithms in Graphs4 citations

TL;DR

This paper presents work-efficient, parallel batch-dynamic algorithms for $k$-clique counting, leveraging parallel fast matrix multiplication and combinatorial enumeration to achieve polylogarithmic depth and low amortized work. It introduces a novel triangle counting algorithm with $O(\Delta\sqrt{\Delta+m})$ amortized work and $O(\log^*(\Delta+m))$ depth, outperforming prior methods on dense graphs and achieving up to 74.73x speedup on a 72-core system.

ABSTRACT

In this paper, we study new batch-dynamic algorithms for the $k$-clique counting problem, which are dynamic algorithms where the updates are batches of edge insertions and deletions. We study this problem in the parallel setting, where the goal is to obtain algorithms with low (polylogarithmic) depth. Our first result is a new parallel batch-dynamic triangle counting algorithm with $O(Δ\sqrt{Δ+m})$ amortized work and $O(\log^* (Δ+m))$ depth with high probability, and $O(Δ+m)$ space for a batch of $Δ$ edge insertions or deletions. Our second result is an algebraic algorithm based on parallel fast matrix multiplication. Assuming that a parallel fast matrix multiplication algorithm exists with parallel matrix multiplication constant $ω_p$, the same algorithm solves dynamic $k$-clique counting with $O\left(\min\left(Δm^{\frac{(2k - 1)ω_p}{3(ω_p + 1)}}, (Δ+m)^{\frac{2(k + 1)ω_p}{3(ω_p + 1)}} ight) ight)$ amortized work and $O(\log (Δ+m))$ depth with high probability, and $O\left((Δ+m)^{\frac{2(k + 1)ω_p}{3(ω_p + 1)}} ight)$ space. Using a recently developed parallel $k$-clique counting algorithm, we also obtain a simple batch-dynamic algorithm for $k$-clique counting on graphs with arboricity $α$ running in $O(Δ(m+Δ)α^{k-4})$ expected work and $O(\log^{k-2} n)$ depth with high probability, and $O(m + Δ)$ space. Finally, we present a multicore CPU implementation of our parallel batch-dynamic triangle counting algorithm. On a 72-core machine with two-way hyper-threading, our implementation achieves 36.54--74.73x parallel speedup, and in certain cases achieves significant speedups over existing parallel algorithms for the problem, which are not theoretically-efficient.

Motivation & Objective

• To design parallel batch-dynamic algorithms for $k$-clique counting that scale efficiently on modern multicore architectures.
• To achieve low amortized work and polylogarithmic depth for dynamic updates, especially for large batches of edge insertions and deletions.
• To develop a theoretically efficient algorithm based on parallel fast matrix multiplication that outperforms existing dynamic approaches on dense graphs.
• To implement and evaluate the proposed algorithms on real and synthetic workloads, demonstrating practical superiority over existing non-theoretically-optimal methods.
• To address the limitations of sequential and single-update dynamic algorithms in high-rate, dynamic graph workloads by enabling batch processing and parallelism.

Proposed method

• Proposes a parallel batch-dynamic triangle counting algorithm using vertex-degree-based work distribution and batch-aware adjacency list updates to minimize redundant computation.
• Employs a novel work-efficient strategy that processes edge updates in batches by tracking changes in common neighbors and updating clique counts incrementally.
• Introduces an algebraic approach based on parallel fast matrix multiplication, with amortized work bounded by $O(\min(\Delta m^{(2k-1)\omega_p/(3(\omega_p+1))}, (\Delta+m)^{2(k+1)\omega_p/(3(\omega_p+1))}))$ for $k$-clique counting.
• Uses low out-degree orientations for graphs with arboricity $\alpha$ to design a simple, enumeration-based batch-dynamic $k$-clique algorithm with $O(\Delta(m+\Delta)\alpha^{k-4})$ expected work and $O(\log^{k-2}n)$ depth.
• Implements the triangle counting algorithm on a 72-core CPU with two-way hyper-threading, optimizing for memory access patterns and load balancing across cores.
• Employs a hybrid approach that detects and eliminates redundant updates (e.g., insert-delete pairs) within batches to reduce unnecessary computation.

Experimental results

Research questions

• RQ1 Can a parallel batch-dynamic algorithm for $k$-clique counting achieve polylogarithmic depth while maintaining low amortized work?
• RQ2 How does the performance of a matrix multiplication-based approach scale with increasing graph density and batch size?
• RQ3 Can a combinatorial, enumeration-based algorithm for $k$-clique counting achieve both theoretical efficiency and practical speedup on real-world graphs?
• RQ4 How does the proposed algorithm compare to existing non-theoretically-optimal parallel algorithms in practice, especially on high-degree vertices and dense graphs?
• RQ5 What is the impact of batch size and graph density on the performance of batch-dynamic triangle counting algorithms?

Key findings

• The proposed parallel batch-dynamic triangle counting algorithm achieves $O(\Delta\sqrt{\Delta+m})$ amortized work and $O(\log^*(\Delta+m))$ depth with high probability, significantly improving upon prior parallel batch-dynamic methods.
• On a 72-core machine with hyper-threading, the implementation achieves 36.54–74.73x parallel speedup, outperforming existing non-theoretically-efficient algorithms on the Twitter graph across all batch sizes.
• For the rMAT synthetic graph, the algorithm achieves up to 3.31× speedup over Makkar et al. [MBG17] on small batches and denser graphs, where their method degrades due to high-degree vertex updates.
• The matrix multiplication-based algorithm achieves asymptotically faster work bounds than existing dynamic approaches on dense graphs, assuming a parallel fast matrix multiplication algorithm with constant $\omega_p$.
• On the Orkut graph, Makkar et al. performs better due to lower-degree vertices, but the proposed algorithm remains competitive and significantly faster on the Twitter graph, which contains high-degree vertices.
• The algorithm’s performance is stable across increasing graph density, while the Makkar et al. algorithm degrades due to degree-dependent update overhead, demonstrating the robustness of the proposed approach.