Honing the Detection of Interference and Ready Dependence for Slicing Concurrent Java Programs ∗

Despite the usefulness of program slicing as a software specialization and debugging tool and the popularity of concurrent object-oriented programming languages such as Java and C#, slicing techniques for these languages have yet to reach the same level of maturity as foundations and implementations of slicing for sequential languages such as C. In particular, efficiently calculating precise slices in the presence of concurrency and synchronization is challenging, because it is difficult to statically reason about the dependences that arise when multiple threads perform interfering reads/writes on shared data. In this paper, we show how previous work on escape analysis and data race detection can be improved to yield a static analysis that is efficient yet effective for reducing the number of interference dependency edges in program dependence graphs used in slicing concurrent Java programs. The key idea is to statically detect situations where run-time heap objects are reachable from a single thread. In these situations, there is no need to make the worse-case assumption that other threads could be interfering with accesses to these objects (thus, many interference dependency edges are eliminated). Our analysis improves on these previous version by detected situations where accesses to an object cannot be interfered with even though the object escapes its allocated thread. We also show how this analysis can reduce the number of ready dependence edges – dependences that arise due to dependences between Java synchronization constructs. The analysis algorithms described here are implemented in Bandera slicer, which is being applied to reduce the size of software models for model-checking.