Skipper: Maximal Matching with a Single Pass over Edges

Maximal Matching (MM) is a fundamental graph problem with diverse applications. While state-of-the-art parallel MM algorithms have a total expected work linear in number of edges, they require randomization, iterative graph processing, and graph pruning after each iteration. These overheads increase execution time and demand additional memory, reducing applicability to large-scale graphs. In this paper, we introduce Skipper, an asynchronous Maximal Matching algorithm that resolves conflicts instantaneously using a parallel reservation strategy, which merges both reservation and committing steps into a single step. Skipper processes each edge only once, definitively determining whether the edge is selected as a match. Skipper does not require graph pruning and minimizes memory space utilization, requiring only a single byte of memory space per vertex. Furthermore, Skipper operates in the asynchronous parallel random access machine (APRAM) model, relaxing synchronization between threads, and facilitating better parallelization gains. Our evaluation, conducted on real-world and synthetic graphs with up to 224 billion edges, shows that Skipper achieves a speedup of 4.9–15.6 times, with a geometric mean of 8.0 times.

💡 Research Summary

**
The paper introduces Skipper, a novel parallel algorithm for computing a maximal matching (MM) in undirected graphs that processes each edge exactly once. Traditional high‑performance parallel MM algorithms rely on the Endpoints Mutual Selection (EMS) paradigm. EMS requires two distinct phases—selection and refinement—and repeats these phases over multiple iterations. After each iteration, matched vertices and all incident edges are removed (graph pruning), and randomization is used to guarantee that the number of unmatched vertices shrinks geometrically. While these techniques achieve an expected linear work bound, they incur substantial overhead: repeated scans of the edge set, costly graph pruning, extra memory for bookkeeping, and synchronization barriers.

Skipper eliminates all of these drawbacks by introducing Just‑In‑Time (JIT) conflict resolution. When a thread examines an edge (u, v), it atomically checks the matched flag of both endpoints. If both flags are clear, the thread atomically sets them (using a compare‑and‑swap or fetch‑add) and declares the edge a match. If either endpoint is already matched, the edge is discarded immediately. Consequently, each edge is examined a single time, and no second “refinement” pass is needed. The algorithm therefore requires only one byte per vertex to store the matched flag, and no auxiliary data structures such as priority queues or sampling tables.

The authors implement Skipper in the Asynchronous Parallel Random Access Machine (APRAM) model. In APRAM, threads operate without global barriers; they only perform atomic operations on shared flags. This asynchrony reduces synchronization latency and better utilizes the memory bandwidth of modern multicore systems, which are typically memory‑bound for graph workloads.

From a theoretical standpoint, Skipper’s expected work is Θ(|E|), matching the optimal bound of EMS‑based algorithms but without the extra logarithmic factors introduced by repeated iterations. The paper provides a proof that JIT conflict resolution yields a maximal matching: after processing all edges, any remaining unselected edge must have at least one endpoint already matched, satisfying the maximality condition.

Experimental Evaluation
The authors evaluate Skipper against the state‑of‑the‑art Sampling‑based Internally‑Deterministic MM (SIDMM) implementation from the Graph‑Based Benchmark Suite (GBBS). Experiments are performed on a 64‑core Intel Xeon server using 12 datasets (both real‑world and synthetic) ranging from 10⁸ to 2.24 × 10¹⁰ edges. Key findings include:

• Speedup: Skipper achieves a speedup of 4.9–15.6× over SIDMM, with a geometric mean of 8.0×. For graphs larger than 5 × 10⁹ edges, the mean speedup rises to 10.3×.
• Memory Access Efficiency: Skipper performs only 0.3–0.8× the number of memory accesses required by the sequential greedy MM (SGMM), whereas SIDMM incurs 33–58× more accesses than SGMM. This dramatic reduction explains the superior scalability.
• Scalability: While absolute performance still depends on memory bandwidth, Skipper scales more gracefully with increasing core counts because it avoids the repeated global synchronization points inherent in EMS‑based methods.

Contributions

1. A thorough analysis of prior parallel MM algorithms, exposing their work inefficiencies.
2. Identification of the fundamental limitation of EMS: the separation of endpoint processing into two passes.
3. Design of Skipper, an asynchronous MM algorithm that processes each edge once and requires only a single byte per vertex.
4. Formal analysis proving linear expected work and maximality without randomization.
5. Empirical validation showing order‑of‑magnitude speedups on massive graphs.

Implications and Future Work
Skipper demonstrates that maximal matching can be realized with minimal memory traffic and synchronization, making it highly suitable for emerging hardware platforms where memory bandwidth is the primary bottleneck (e.g., many‑core CPUs, NUMA systems). The authors suggest extending the JIT reservation concept to other graph problems such as maximal independent set, vertex cover, or even to distributed settings where communication costs dominate. Additionally, exploring GPU or FPGA implementations could further amplify the benefits of a single‑pass, conflict‑free design.

In summary, Skipper represents a significant step forward in parallel graph algorithms: by collapsing selection and commitment into a single atomic operation and embracing an asynchronous execution model, it achieves both theoretical optimality and practical performance on today’s largest graph datasets.