Compilers: principles, techniques, and tools
Compilers: principles, techniques, and tools
The program summary graph and flow-sensitive interprocedual data flow analysis
PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
Integrating noninterfering versions of programs
ACM Transactions on Programming Languages and Systems (TOPLAS)
Interprocedural slicing using dependence graphs
ACM Transactions on Programming Languages and Systems (TOPLAS)
An interval-based approach to exhaustive and incremental interprocedural data-flow analysis
ACM Transactions on Programming Languages and Systems (TOPLAS)
Introduction to algorithms
The semantic approach to program slicing
PLDI '91 Proceedings of the ACM SIGPLAN 1991 conference on Programming language design and implementation
Using Program Slicing in Software Maintenance
IEEE Transactions on Software Engineering
A program integration algorithm that accommodates semantics-preserving transformations
ACM Transactions on Software Engineering and Methodology (TOSEM)
Automatic partitioning of a program dependence graph into parallel tasks
IBM Journal of Research and Development
Dependence-based program analysis
PLDI '93 Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation
Debugging with dynamic slicing and backtracking
Software—Practice & Experience
SIGSOFT '94 Proceedings of the 2nd ACM SIGSOFT symposium on Foundations of software engineering
Program integration for languages with procedure calls
ACM Transactions on Software Engineering and Methodology (TOSEM)
Optimizing parallel programs with explicit synchronization
PLDI '95 Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation
Program and interface slicing for reverse engineering
ICSE '93 Proceedings of the 15th international conference on Software Engineering
Computation of interprocedural control dependence
Proceedings of the 1998 ACM SIGSOFT international symposium on Software testing and analysis
Static slicing of threaded programs
Proceedings of the 1998 ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering
Pointer analysis for multithreaded programs
Proceedings of the ACM SIGPLAN 1999 conference on Programming language design and implementation
System-dependence-graph-based slicing of programs with arbitrary interprocedural control flow
Proceedings of the 21st international conference on Software engineering
An application of compiler technology to the year 2000 problem
Software—Practice & Experience
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Compositional pointer and escape analysis for Java programs
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Proceedings of the 2000 ACM SIGSOFT international symposium on Software testing and analysis
Context-sensitive synchronization-sensitive analysis is undecidable
ACM Transactions on Programming Languages and Systems (TOPLAS)
Effective synchronization removal for Java
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
Slicing concurrent java programs
ACM SIGPLAN Notices
Pointer and escape analysis for multithreaded programs
PPoPP '01 Proceedings of the eighth ACM SIGPLAN symposium on Principles and practices of parallel programming
On optimal slicing of parallel programs
STOC '01 Proceedings of the thirty-third annual ACM symposium on Theory of computing
Concurrent SSA Form in the Presence of Mutual Exclusion
ICPP '98 Proceedings of the 1998 International Conference on Parallel Processing
Slicing Concurrent Programs - A Graph-Theoretical Approach
AADEBUG '93 Proceedings of the First International Workshop on Automated and Algorithmic Debugging
The program dependence graph in a software development environment
SDE 1 Proceedings of the first ACM SIGSOFT/SIGPLAN software engineering symposium on Practical software development environments
Channel Dependence Analysis for Slicing Promela
PDSE '99 Proceedings of the International Symposium on Software Engineering for Parallel and Distributed Systems
Slicing Concurrent Java Programs
IWPC '99 Proceedings of the 7th International Workshop on Program Comprehension
Context-sensitive slicing of concurrent programs
Proceedings of the 9th European software engineering conference held jointly with 11th ACM SIGSOFT international symposium on Foundations of software engineering
Pointer analysis of multithreaded Java programs
Proceedings of the 2003 ACM symposium on Applied computing
Journal of Systems and Software
Precise slicing of concurrent programs
Automated Software Engineering
Program dependence graph based slicing for Java
SEA '07 Proceedings of the 11th IASTED International Conference on Software Engineering and Applications
Discovering Coordination Patterns
Electronic Notes in Theoretical Computer Science (ENTCS)
A trace simplification technique for effective debugging of concurrent programs
Proceedings of the eighteenth ACM SIGSOFT international symposium on Foundations of software engineering
Advanced chopping of sequential and concurrent programs
Software Quality Control
LEAN: simplifying concurrency bug reproduction via replay-supported execution reduction
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
DrDebug: Deterministic Replay based Cyclic Debugging with Dynamic Slicing
Proceedings of Annual IEEE/ACM International Symposium on Code Generation and Optimization
Hi-index | 0.00 |
Slicing is a well-known program reduction technique where for a given program P and a variable of interest v at some statement P in the program, a program slice contains those set of statements belonging to P that affect v. This article presents two algorithms for interprocedural slicing of concurrent programs--a context-insensitive algorithm and a context-sensitive algorithm. The context-insensitive algorithm is efficient and correct (it includes every statement that may affect the slicing criterion) but is imprecise since it may include certain extra statements that are unnecessary. Precise slicing has been shown to be undecidable for concurrent programs. However, the context-sensitive algorithm computes correct and reasonably precise slices, but has a worst-case exponential-time complexity. Our context-sensitive algorithm computes a closure of dependencies while ensuring that statements sliced in each thread belong to a realizable path in that thread.A realizable path in a thread with procedure calls is one that reflects the fact that when a procedure finishes, execution returns to the site of the most recently executed call in that thread. One of the novelties of this article is a practical solution to determine whether a given set of statements in a thread may belong to a realizable path. This solution is precise even in the presence of recursion and long call chains in the flow graph.The slicing algorithms are applicable to concurrent programs with shared memory, interleaving semantics, explicit wait/notify synchronization and monitors. We first give a solution for a simple model of concurrency and later show how to extend the solution to the Java concurrency model. We have implemented the algorithms for Java bytecode and give experimental results.