[Paper] Dynamic Contract Analysis for Parallel Programming Models

Source: arXiv - 2603.03023v1

Overview

The paper introduces CoVer‑Dynamic, a runtime (dynamic) analysis extension that builds on the existing static verifier CoVer. By re‑using CoVer’s contract language, the authors create a single framework that can check user‑defined correctness rules both at compile‑time and while the program is running. This hybrid approach dramatically reduces false positives and catches bugs that static analysis alone misses, especially in MPI and OpenSHMEM parallel applications.

Key Contributions

• Unified contract language: The same declarative contracts used for static checking are enforced at runtime, eliminating the need for separate tooling per programming model.
• Dynamic verification engine (CoVer‑Dynamic): Implements contract enforcement with low overhead, handling runtime‑dependent phenomena such as pointer aliasing and indirect control flow.
• Empirical evaluation: Shows that CoVer‑Dynamic eliminates false positives on standard MPI/OpenSHMEM benchmarks and discovers additional bugs missed by static analysis.
• Performance advantage: Achieves an average 2× speedup over the leading MPI correctness checker MUST, while providing comparable or better bug‑detection coverage.
• Open‑ended extensibility: Demonstrates how new or experimental parallel programming models can be supported simply by writing contracts, without rewriting the analysis core.

Methodology

1. Contract Specification – Developers write contracts in CoVer’s DSL (e.g., “every MPI_Send must be matched by a corresponding MPI_Recv on the same communicator”).
2. Static Phase (CoVer) – The source code is parsed, and the contracts are checked where possible using data‑flow and alias analysis.
3. Instrumentation – The compiler inserts lightweight hooks around parallel API calls (MPI, OpenSHMEM, etc.). These hooks invoke the runtime contract engine.
4. Dynamic Phase (CoVer‑Dynamic) – At execution time, the engine maintains the contract state (e.g., pending sends, resource usage) and validates each operation against the contracts. Violations are reported instantly.
5. Benchmark Suite – The authors evaluate on a collection of MPI and OpenSHMEM programs from the MPI Correctness Test Suite and OSHMEM Benchmarks, comparing detection rates and overhead against MUST.

Results & Findings

The results indicate that reusing the same contracts eliminates many spurious warnings that static‑only tools generate, and that the dynamic checks add only modest overhead while catching subtle bugs that depend on actual execution paths.

Practical Implications

• Faster debugging cycles – Developers get immediate feedback during test runs, reducing time spent chasing false alarms.
• Model‑agnostic verification – Teams can adopt emerging parallel APIs (e.g., PGAS languages, custom collective operations) by writing a few contracts instead of waiting for dedicated static analyzers.
• Continuous‑integration friendly – CoVer‑Dynamic’s low overhead makes it suitable for nightly CI pipelines on HPC clusters, ensuring contract violations are caught before code reaches production.
• Resource‑usage auditing – Contracts can be extended to monitor memory buffers, communicator lifetimes, or GPU‑direct transfers, helping prevent leaks and deadlocks in large‑scale jobs.
• Educational tool – New HPC developers can learn correct MPI/OpenSHMEM patterns by observing contract violations in small test programs.

Limitations & Future Work

• Expressiveness gap – Some error classes (e.g., complex non‑deterministic race conditions, performance‑related contracts) cannot yet be captured in the current DSL.
• Scalability to extreme‑scale runs – While overhead is modest on the benchmark suite, the authors note that maintaining contract state for millions of concurrent operations may require distributed bookkeeping.
• Support for mixed‑language programs – The current implementation focuses on C/C++ MPI/OpenSHMEM; extending to Fortran or hybrid CPU‑GPU codes is left for later work.
• Automated contract generation – Future research aims to infer common contracts from existing codebases, reducing the manual effort required from developers.

Overall, CoVer‑Dynamic showcases a pragmatic path toward more reliable parallel software by unifying static and dynamic verification under a single, developer‑friendly contract system.

Authors

• Yussur Mustafa Oraji
• Alexander Hück
• Christian Bischof

Paper Information

• arXiv ID: 2603.03023v1
• Categories: cs.DC
• Published: March 3, 2026
• PDF: Download PDF