Massively Parallel Algorithms for Approximate Shortest Paths

2024-06-17

ACM Symposium on Parallelism in Algorithms and Architectures

AI Summary

For approximate shortest path computation on unweighted undirected graphs, this paper breaks the long-standing Ω(log n) round lower bound by achieving poly(log log n) rounds in the near-linear memory Massively Parallel Computation (MPC) model—the first such result. We introduce MPC-customized technical primitives: bounded-scale hopsets, near-additive emulators, and multi-scale distance sketches—designed via randomized construction and graph compression techniques to uniformly support both sublinear and near-linear memory MPC regimes. Our algorithm supports (1+ε)-approximate single-source shortest paths (SSSP) and (1+ε)(2k−1)-approximate all-pairs distance queries with O(1) query latency. Total memory consumption is Õ(mn^ρ) or Õ((m + n^{1+ρ})n^{1/k}), while the memory per machine remains Õ(n). This work establishes a new round complexity frontier for distributed shortest path approximation in MPC.

Technology Category

• Search and Optimization: Distributed Search
• Machine Learning: Graph-based Machine Learning
• Constraint Satisfaction and Optimization: Distributed CSP/Optimization

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Security and Privacy: Large-scale security measurements
• Economics, Online Markets and Human Computation: Incentives in network design for Web infrastructures and ecosystems

Abstract

We present fast algorithms for approximate shortest paths in the massively parallel computation (MPC) model. We provide randomized algorithms that take poly(łogłogn ) rounds in the near-linear memory MPC model. Our results are for unweighted undirected graphs with n vertices and m edges. Our first contribution is a (1+ε)-approximation algorithm for Single-Source Shortest Paths (SSSP) that takes poly(łogłogn ) rounds in the near-linear MPC model, where the memory per machine is Õ(n) and the total memory is Õ (mn^ρ ), where ρ is a small constant. Our second contribution is a distance oracle that allows to approximate the distance between any pair of vertices. The distance oracle is constructed in poly(łogłogn ) rounds and allows to query a (1+ε)(2k-1)-approximate distance between any pair of vertices u and v in O(1) additional rounds. The algorithm is for the near-linear memory MPC model with total memory of size Õ((m+n^1+ρ )n^1/k ), where ρ is a small constant. While our algorithms are for the near-linear MPC model, in fact they only use one machine with Õ(n) memory, where the rest of machines can have sublinear memory of size O(n^γ ) for a small constant γ < 1. All previous algorithms for approximate shortest paths in the near-linear MPC model either required Ω(łogn ) rounds or had an Ω(łogn ) approximation. Our approach is based on fast construction of near-additive emulators, limited-scale hopsets and limited-scale distance sketches that are tailored for the MPC model. While our end-results are for the near-linear MPC model, many of the tools we construct such as hopsets and emulators are constructed in the more restricted sublinear MPC model.

Problem

• Develop fast approximate shortest path algorithms in MPC model
• Construct efficient distance oracles for vertex pair queries
• Achieve poly(log log n) round complexity with near-linear memory

Innovation

• Fast $(1+epsilon)$-approximation SSSP in $poly(log{log{n}})$ rounds
• Distance oracle for $(1+epsilon)(2k-1)$-approximate queries
• Near-additive emulators tailored for MPC model