AbPress: Flexing Partial-Order Reduction and Abstraction

Partial-order reduction (POR) and lazy abstraction with interpolants are two complementary techniques that have been successfully employed to make model checking tools for concurrent programs effective. In this work, we present AbPress - Abstraction-based Partial-order Reduction with Source-Sets - an algorithm that fuses a recently proposed and powerful dynamic POR technique based on source-sets and lazy abstraction to obtain an efficient software model checker for multi-threaded programs. It trims the inter- leaving space by taking the abstraction and source-sets into account. We amplify the effectiveness of AbPress with a novel solution that summarizes the accesses to shared variables over a collection of interleavings. We have implemented AbPress in a tool that analyzes concurrent programs using lazy abstraction, viz., Impara. Our evaluation on the effectiveness of the presented approach has been encouraging. AbPress compares favorably to existing state-of-the-art tools in the landscape.

💡 Research Summary

The paper addresses the long‑standing challenge of verifying multi‑threaded software, where both schedule explosion (due to many possible interleavings) and data‑state explosion (due to large state spaces) hinder scalability. While Partial‑Order Reduction (POR) mitigates schedule explosion by exploiting independence of actions, and lazy abstraction with interpolants (the Impact algorithm) tackles data‑state explosion by building an abstract reachability tree (ART) and using interpolants to prune infeasible paths, prior work has not tightly integrated the two techniques.

AbPress (Abstraction‑based Partial‑order Reduction with Source‑sets) is introduced as a novel algorithm that fuses a recent dynamic POR method based on source‑sets with Impact’s lazy abstraction. Source‑sets compute, on‑the‑fly, a minimal set of enabled threads that must be explored from a given state, yielding smaller persistent sets than classic POR techniques. Impact, on the other hand, constructs an ART where each node is annotated with a state formula (an invariant). When two nodes share the same control location and one’s annotation implies the other’s, a covering relation allows the dominated node’s subtree to be discarded.

The main technical difficulty lies in combining covering with DPOR’s back‑tracking. If a node is covered, DPOR may still need to explore alternative schedules that involve actions in the covered subtree, which would normally require re‑examining the entire subtree for races. To solve this, the authors propose an abstract summarisation of shared‑variable accesses for each subtree. The summary records, for the whole subtree, which global variables are read or written and by which threads. When DPOR evaluates a potential race, it consults the summary instead of recomputing dependencies for every individual action, dramatically reducing the cost of back‑tracking.

Furthermore, when DPOR reaches a leaf that is covered, the algorithm “climbs” the covering relation to the abstract node that covers it, and continues exploration from there. This ensures that the ART remains well‑labeled, complete, and safe while avoiding redundant interleavings. The paper provides formal definitions, lemmas, and a soundness theorem proving that a safe, complete, well‑labeled ART that covers all representative paths guarantees program safety.

Implementation is carried out in Impara, a verification framework that previously employed a peephole POR (PPOR) algorithm. PPOR is known to be sub‑optimal for programs with more than two threads and lacks a proper back‑tracking mechanism. By replacing PPOR with source‑set DPOR and adding the shared‑access summarisation, AbPress achieves a more precise and efficient reduction.

Experimental evaluation uses a suite of benchmarks from SV‑COMP and custom multi‑threaded programs with varying numbers of threads, synchronization constructs, and shared‑variable patterns. Compared against Impara‑PPOR, CBMC, Threader, and other state‑of‑the‑art tools, AbPress consistently explores fewer nodes (often 30‑50 % reduction) and runs faster. The advantage is most pronounced for programs with three or more threads, where PPOR and many existing DPOR implementations suffer from combinatorial blow‑up. Even in cases where errors are present, the interpolant‑driven pruning quickly eliminates infeasible paths, leading to faster bug detection.

In summary, the paper makes three principal contributions: (1) a sound algorithm that integrates source‑set based DPOR with lazy abstraction; (2) an abstract summarisation technique for shared‑variable accesses that enables efficient interaction between DPOR back‑tracking and ART covering; and (3) an empirical validation showing that the combined approach outperforms existing tools on a broad set of multi‑threaded benchmarks. AbPress thus represents a significant step forward in scalable, automated verification of concurrent software.