Programming with sets; an introduction to SETL
Programming with sets; an introduction to SETL
The synthesizer generator: a system for constructing language-based editors
The synthesizer generator: a system for constructing language-based editors
Program derivation by fixed point computation
Science of Computer Programming
Separating binding times in language specifications
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
Static type inference in a dynamically typed language
POPL '91 Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Soft typing with conditional types
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Set-based analysis of ML programs
LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
Systematic derivation of incremental programs
Science of Computer Programming
Binding-time analysis for standard ML
Lisp and Symbolic Computation - Special issue on partial evaluation and semantics-based program manipulation (PEPM '94)
Formal language, grammar and set-constraint-based program analysis by abstract interpretation
FPCA '95 Proceedings of the seventh international conference on Functional programming languages and computer architecture
Points-to analysis in almost linear time
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Linear-time subtransitive control flow analysis
Proceedings of the ACM SIGPLAN 1997 conference on Programming language design and implementation
Partial online cycle elimination in inclusion constraint graphs
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Static caching for incremental computation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Componential set-based analysis
ACM Transactions on Programming Languages and Systems (TOPLAS)
Projection merging: reducing redundancies in inclusion constraint graphs
Proceedings of the 27th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Finite Differencing of Computable Expressions
ACM Transactions on Programming Languages and Systems (TOPLAS)
Efficiency by Incrementalization: An Introduction
Higher-Order and Symbolic Computation
Principles of Database and Knowledge-Base Systems: Volume II: The New Technologies
Principles of Database and Knowledge-Base Systems: Volume II: The New Technologies
Principles of Program Analysis
Principles of Program Analysis
The Design and Analysis of Computer Algorithms
The Design and Analysis of Computer Algorithms
Propagating Differences: An Efficient New Fixpoint Algorithm for Distributive Constraint Systems
ESOP '98 Proceedings of the 7th European Symposium on Programming: Programming Languages and Systems
Dynamic Programming via Static Incrementalization
ESOP '99 Proceedings of the 8th European Symposium on Programming Languages and Systems
Efficient Type Inference for Higher-Order Binding-Time Analysis
Proceedings of the 5th ACM Conference on Functional Programming Languages and Computer Architecture
Set Constraints and Set-Based Analysis
PPCP '94 Proceedings of the Second International Workshop on Principles and Practice of Constraint Programming
Eliminating Dead Code on Recursive Data
SAS '99 Proceedings of the 6th International Symposium on Static Analysis
On the Complexity Analysis of Static Analyses
SAS '99 Proceedings of the 6th International Symposium on Static Analysis
Program Specialization via Program Slicing
Selected Papers from the Internaltional Seminar on Partial Evaluation
Points-to Analysis by Type Inference of Programs with Structures and Unions
CC '96 Proceedings of the 6th International Conference on Compiler Construction
A language-theoretic approach to algorithms
A language-theoretic approach to algorithms
IEEE Software
Hi-index | 0.00 |
This paper describes the precise specification, design, analysis, implementation, and measurements of an efficient algorithm for solving regular tree grammar based constraints. The particular constraints are for dead-code elimination on recursive data, but the method used for the algorithm design and complexity analysis is general and applies to other program analysis problems as well. The method is centered around Paige's finite differencing, i.e., computing expensive set expressions incrementally, and allows the algorithm to be derived and analyzed formally and implemented easily. We propose higher-level transformations that make the derived algorithm concise and allow its complexity to be analyzed accurately. Although a rough analysis shows that the worst-case time complexity is cubic in program size, an accurate analysis shows that it is linear in the number of live program points and in other parameters, including mainly the arity of data constructors and the number of selector applications into whose arguments the value constructed at a program point might flow. These parameters explain the performance of the analysis in practice. Our implementation also runs two to ten times as fast as a previous implementation of an informally designed algorithm.