## Imperative self-adjusting computation (2008)

### Cached

### Download Links

- [people.cs.uchicago.edu]
- [www.cs.uchicago.edu]
- [ttic.uchicago.edu]
- [www.cs.uchicago.edu]
- DBLP

### Other Repositories/Bibliography

Venue: | In POPL ’08: Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages |

Citations: | 27 - 16 self |

### BibTeX

@INPROCEEDINGS{Acar08imperativeself-adjusting,

author = {Umut A. Acar and Amal Ahmed and Matthias Blume},

title = {Imperative self-adjusting computation},

booktitle = {In POPL ’08: Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages},

year = {2008},

pages = {309--322}

}

### Years of Citing Articles

### OpenURL

### Abstract

Recent work on self-adjusting 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 write-operations, 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 ad-hoc solutions had previously remained elusive. All previous work on self-adjusting 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 change-propagation semantics. AIL closely resembles a traditional higher-order imperative programming language. For AIL we state and prove consistency, i.e., the property that although the semantics is inherently non-deterministic, 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 step-indexed logical relation that handles modifiable references. We show that AIL can be realized efficiently by describing implementation strategies whose overhead is provably constant-time 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.