Results 1  10
of
22
Incremental contextdependent analysis for languagebased editors
 ACM Transactions on Programming Languages and Systems
, 1983
"... Knowledge of a programming language's grammar allows languagebased editors to enforce syntactic correctness at all times during development by restricting editing operations to legitimate modifications ot ~ the program's contextfree derivation tree; however, not all language constraints can be enf ..."
Abstract

Cited by 81 (10 self)
 Add to MetaCart
Knowledge of a programming language's grammar allows languagebased editors to enforce syntactic correctness at all times during development by restricting editing operations to legitimate modifications ot ~ the program's contextfree derivation tree; however, not all language constraints can be enforced in this way because not all features can be described by the contextfree formalism. Attribute grammars permit contextdependent language features to be expressed in a modular, declarative fashion and thus are a good basis for specifying languagebased editors. Such editors represent programs as attributed trees, Which are modified by operations such as subtree pruning and grafting. Incremental analysis is performed by updating attribute values after every modification. This paper discusses how updating can be carried out and presents several algorithms for the task, including one that is asymptotically optimal in time.
Adaptive Functional Programming
 IN PROCEEDINGS OF THE 29TH ANNUAL ACM SYMPOSIUM ON PRINCIPLES OF PROGRAMMING LANGUAGES
, 2001
"... An adaptive computation maintains the relationship between its input and output as the input changes. Although various techniques for adaptive computing have been proposed, they remain limited in their scope of applicability. We propose a general mechanism for adaptive computing that enables one to ..."
Abstract

Cited by 64 (23 self)
 Add to MetaCart
An adaptive computation maintains the relationship between its input and output as the input changes. Although various techniques for adaptive computing have been proposed, they remain limited in their scope of applicability. We propose a general mechanism for adaptive computing that enables one to make any purelyfunctional program adaptive. We show
On the Computational Complexity of Dynamic Graph Problems
 THEORETICAL COMPUTER SCIENCE
, 1996
"... ..."
An experimental analysis of selfadjusting computation
 In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI
, 2006
"... Selfadjusting computation uses a combination of dynamic dependence graphs and memoization to efficiently update the output of a program as the input changes incrementally or dynamically over time. Related work showed various theoretical results, indicating that the approach can be effective for a r ..."
Abstract

Cited by 35 (19 self)
 Add to MetaCart
Selfadjusting computation uses a combination of dynamic dependence graphs and memoization to efficiently update the output of a program as the input changes incrementally or dynamically over time. Related work showed various theoretical results, indicating that the approach can be effective for a reasonably broad range of applications. In this article, we describe algorithms and implementation techniques to realize selfadjusting computation and present an experimental evaluation of the proposed approach on a variety of applications, ranging from simple list primitives to more sophisticated computational geometry algorithms. The results of the experiments show that the approach is effective in practice, often offering orders of magnitude speedup from recomputing the output from scratch. We believe this is the first experimental evidence that incremental computation of any type is effective in practice for a reasonably broad set of applications.
SelfAdjusting Computation
 In ACM SIGPLAN Workshop on ML
, 2005
"... From the algorithmic perspective, we describe novel data structures for tracking the dependences ina computation and a changepropagation algorithm for adjusting computations to changes. We show that the overhead of our dependence tracking techniques is O(1). To determine the effectiveness of change ..."
Abstract

Cited by 35 (13 self)
 Add to MetaCart
From the algorithmic perspective, we describe novel data structures for tracking the dependences ina computation and a changepropagation algorithm for adjusting computations to changes. We show that the overhead of our dependence tracking techniques is O(1). To determine the effectiveness of changepropagation, we present an analysis technique, called trace stability, and apply it to a number of applications.
Imperative selfadjusting computation
 In POPL ’08: Proceedings of the 35th annual ACM SIGPLANSIGACT symposium on Principles of programming languages
, 2008
"... Recent work on selfadjusting computation showed how to systematically write programs that respond efficiently to incremental changes in their inputs. The idea is to represent changeable data using modifiable references, i.e., a special data structure that keeps track of dependencies between read an ..."
Abstract

Cited by 27 (16 self)
 Add to MetaCart
Recent work on selfadjusting computation showed how to systematically write programs that respond efficiently to incremental changes in their inputs. The idea is to represent changeable data using modifiable references, i.e., a special data structure that keeps track of dependencies between read and writeoperations, and to let computations construct traces that later, after changes have occurred, can drive a change propagation algorithm. The approach has been shown to be effective for a variety of algorithmic problems, including some for which adhoc solutions had previously remained elusive. All previous work on selfadjusting computation, however, relied on a purely functional programming model. In this paper, we show that it is possible to remove this limitation and support modifiable references that can be written multiple times. We formalize this using a language AIL for which we define evaluation and changepropagation semantics. AIL closely resembles a traditional higherorder imperative programming language. For AIL we state and prove consistency, i.e., the property that although the semantics is inherently nondeterministic, different evaluation paths will still give observationally equivalent results. In the imperative setting where pointer graphs in the store can form cycles, our previous proof techniques do not apply. Instead, we make use of a novel form of a stepindexed logical relation that handles modifiable references. We show that AIL can be realized efficiently by describing implementation strategies whose overhead is provably constanttime per primitive. When the number of reads and writes per modifiable is bounded by a constant, we can show that change propagation becomes as efficient as it was in the pure case. The general case incurs a slowdown that is logarithmic in the maximum number of such operations. We use DFS and related algorithms on graphs as our running examples and prove that they respond to insertions and deletions of edges efficiently. 1.
Incremental algorithms for interprocedural analysis of safety properties
, 2005
"... Automatonbased static program analysis has proved to be an effective tool for bug finding. Current tools generally reanalyze a program from scratch in response to a change in the code, which can result in much duplicated effort. We present an interprocedural algorithm that analyzes incrementally ..."
Abstract

Cited by 20 (0 self)
 Add to MetaCart
Automatonbased static program analysis has proved to be an effective tool for bug finding. Current tools generally reanalyze a program from scratch in response to a change in the code, which can result in much duplicated effort. We present an interprocedural algorithm that analyzes incrementally in response to program changes and present experiments for a nullpointer dereference analysis. It shows a substantial speedup over reanalysis from scratch, with a manageable amount of disk space used to store information between analysis runs.
A Dynamic Algorithm for Topologically Sorting Directed Acyclic Graphs
, 2004
"... We consider how to maintain the topological order of a directed acyclic graph (DAG) in the presence of edge insertions and deletions. We present a new algorithm and, although this has marginally inferior time complexity compared with the best previously known result, we find that its simplicity lead ..."
Abstract

Cited by 15 (1 self)
 Add to MetaCart
We consider how to maintain the topological order of a directed acyclic graph (DAG) in the presence of edge insertions and deletions. We present a new algorithm and, although this has marginally inferior time complexity compared with the best previously known result, we find that its simplicity leads to better performance in practice. In addition, we provide an empirical comparison against three alternatives over a large number of random DAG's. The results show our algorithm is the best for sparse graphs and, surprisingly, that an alternative with poor theoretical complexity performs marginally better on dense graphs.
An Incremental Algorithm for Maintaining the Dominator Tree of a Reducible Flowgraph
 IN ANNUAL ACM SYMPOSIUM ON PRINCIPLES OF PROGRAMMING LANGUAGES (POPL
, 1994
"... We present a new incremental algorithm for the problem of maintaining the dominator tree of a reducible flowgraph as the flowgraph undergoes changes such as the insertion and deletion of edges. Such an algorithm has applications in incremental dataflow analysis and incremental compilation. ..."
Abstract

Cited by 13 (1 self)
 Add to MetaCart
We present a new incremental algorithm for the problem of maintaining the dominator tree of a reducible flowgraph as the flowgraph undergoes changes such as the insertion and deletion of edges. Such an algorithm has applications in incremental dataflow analysis and incremental compilation.