## 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 |

Citations: | 27 - 16 self |

### BibTeX

@TECHREPORT{Acar08imperativeself-adjusting,

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

title = {Imperative self-adjusting computation},

institution = {In POPL},

year = {2008}

}

### OpenURL

### Abstract

Self-adjusting computation enables writing programs that can automatically and efficiently respond to changes to their data (e.g., inputs). The idea behind the approach is to store all data that can change over time in modifiable references and to let computations construct traces that can drive change propagation. After changes have occurred, change propagation updates the result of the computation by re-evaluating only those expressions that depend on the changed data. Previous approaches to selfadjusting computation require that modifiable references be written at most once during execution—this makes the model applicable only in a purely functional setting. In this paper, we present techniques for imperative self-adjusting computation where modifiable references can be written multiple times. We define a language SAIL (Self-Adjusting Imperative Language) and prove consistency, i.e., that change propagation and from-scratch execution are observationally equivalent. Since SAIL programs are imperative, they can create cyclic data structures. To prove equivalence in the presence of cycles in the store, we formulate and use an untyped, step-indexed logical relation, where step indices are used to ensure well-foundedness. We show that SAIL accepts an asymptotically efficient implementation by presenting algorithms and data structures for its implementation. When the number of operations (reads and writes) per modifiable is bounded by a constant, we show that change propagation becomes as efficient as in the non-imperative case. The general case incurs a slowdown that is logarithmic in the maximum number of such operations. We describe a prototype implementation of SAIL as a Standard ML library. 1