Proceedings of the ACM on Programming Languages· 2026Q1
Revisiting Path Coverage Tracing from a Node-Centric View
- 1citations
- Q1SCImago
- 2026year
Short summary
A new node-centric approach to path coverage tracing reduces instrumentation by 2.8x and runtime overhead by 2.4x compared to state-of-the-art edge-centric methods, enabling faster program analysis and bug detection.
AI-generated from the title and abstract; the full text is not read.
Key points
- Introduces a node-centric view for path coverage tracing, focusing on blocks instead of edges.
- Develops a linear-time, provably optimal algorithm to find the minimum set of blocks for coverage differentiation.
- InsOpt, the implementation, requires 2.8x less instrumentation and instruments only 17% of basic blocks.
- Achieves a 1.6x speedup and a 2.4x reduction in runtime overhead compared to edge-based methods on the Magma benchmark.
- Demonstrates significant performance improvements in fuzzing applications, including a 5.0x speedup in vulnerability detection with AFL++.
AI-generated from the title and abstract; the full text is not read.
Abstract
Path coverage tracing is one of the fundamental components for supporting a wide range of dynamic program analyses, such as testing, debugging, profiling, and many others. Since one needs to insert code into a program to trace its coverage, runtime overhead becomes the main bottleneck for scalability. As finding the minimum number of instrumentation points is NP-hard, extensive work has focused on reducing the number of instrumented edges under diverse assumptions, and thus suffers from the trade-off between precision and efficiency. Departing from this edge-centric view, we introduce, in this work, a novel perspective, namely the node-centric view, where we aim to find the minimum number of blocks, rather than edges as in existing work, that can differentiate all edges and paths in the program. This new perspective allows us to design a linear-time algorithm that is provably correct and optimal—it finds the minimum set of blocks for correctly differentiating edge/path coverage for arbitrary control-flow graphs. Our key insight is that optimal node-level instrumentation only needs to distinguish undifferentiated paths at the block where they converge, enabling our algorithm to have linear-time complexity regarding the number of basic blocks. We implement our algorithm as InsOpt and compare it against state-of-the-art edge-coverage instru- mentation techniques on the real-world vulnerability-detection benchmark, Magma. Our evaluation results demonstrate significant improvements: InsOpt needs 2.8x less instrumentation with only 17% basic blocks instrumented. This reduced instrumentation yields a 1.6x speedup and a substantial 2.4x reduction in runtime overhead. Moreover, we also demonstrate substantial potential for InsOpt across other applications. Specifically, our integration of InsOpt with AFL++, a state-of-the-art fuzzer, shows a 5.0x speedup in vulnerability detection and a 1.5x performance improvement. Notably, this efficiency gain further benefits InsOpt in detecting five previously unknown bugs in frequently evaluated projects by other state-of-the-art tools.
The authors' abstract, as published at the source. Proceedings of the ACM on Programming Languages, 2026 · DOI ↗
Continue with a free account
Ask the paper: 3 free questions a day about this paper; save it, get its citation, new summaries every day for your field. Takeaways are Premium.
Continue free on the webSign in with Google or Apple; no card needed. You come back to this paper.
On your phone:
Field: Software
SoftwareComputer Science