Computational geometry: an introduction
Computational geometry: an introduction
Incremental computation via function caching
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
INC: a language for incremental computations
ACM Transactions on Programming Languages and Systems (TOPLAS)
CPS-transformation after strictness analysis
ACM Letters on Programming Languages and Systems (LOPLAS)
A categorized bibliography on incremental computation
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Analysis and caching of dependencies
Proceedings of the first ACM SIGPLAN international conference on Functional programming
The quickhull algorithm for convex hulls
ACM Transactions on Mathematical Software (TOMS)
ICFP '97 Proceedings of the second ACM SIGPLAN international conference on Functional programming
Static caching for incremental computation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Caching function calls using precise dependencies
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
Adaptive functional programming
POPL '02 Proceedings of the 29th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Incremental evaluation for attribute grammars with application to syntax-directed editors
POPL '81 Proceedings of the 8th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Monads for incremental computing
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
Functional reactive programming, continued
Proceedings of the 2002 ACM SIGPLAN workshop on Haskell
Optimal-time incremental semantic analysis for syntax-directed editors
POPL '82 Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Comparing Control Constructs by Double-Barrelled CPS
Higher-Order and Symbolic Computation
On the Transformation between Direct and Continuation Semantics
Proceedings of the 9th International Conference on Mathematical Foundations of Programming Semantics
Functional Implementations of Continuous Modeled Animation
PLILP '98/ALP '98 Proceedings of the 10th International Symposium on Principles of Declarative Programming
Dynamic Programming
An experimental analysis of self-adjusting computation
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Lowering: a static optimization technique for transparent functional reactivity
Proceedings of the 2007 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
DITTO: automatic incrementalization of data structure invariant checks (in Java)
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Kinetic algorithms via self-adjusting computation
ESA'06 Proceedings of the 14th conference on Annual European Symposium - Volume 14
Imperative self-adjusting computation
Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Memory management for self-adjusting computation
Proceedings of the 7th international symposium on Memory management
A Library for Self-Adjusting Computation
Electronic Notes in Theoretical Computer Science (ENTCS)
Embedding dynamic dataflow in a call-by-value language
ESOP'06 Proceedings of the 15th European conference on Programming Languages and Systems
A cost semantics for self-adjusting computation
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Self-adjusting computation: (an overview)
Proceedings of the 2009 ACM SIGPLAN workshop on Partial evaluation and program manipulation
CEAL: a C-based language for self-adjusting computation
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
An experimental analysis of self-adjusting computation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Partial memoization of concurrency and communication
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
Traceable data types for self-adjusting computation
PLDI '10 Proceedings of the 2010 ACM SIGPLAN conference on Programming language design and implementation
Self-adjusting computation with Delta ML
AFP'08 Proceedings of the 6th international conference on Advanced functional programming
Implicit self-adjusting computation for purely functional programs
Proceedings of the 16th ACM SIGPLAN international conference on Functional programming
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
Composing transformations for instrumentation and optimization
PEPM '12 Proceedings of the ACM SIGPLAN 2012 workshop on Partial evaluation and program manipulation
Type-directed automatic incrementalization
Proceedings of the 33rd ACM SIGPLAN conference on Programming Language Design and Implementation
Non-monotonic self-adjusting computation
ESOP'12 Proceedings of the 21st European conference on Programming Languages and Systems
Hi-index | 0.00 |
Self-adjusting programs respond automatically and efficiently to input changes by tracking the dynamic data dependences of the computation and incrementally updating the output as needed. In order to identify data dependences, previously proposed approaches require the user to make use of a set of monadic primitives. Rewriting an ordinary program into a self-adjusting program with these primitives, however, can be difficult and error-prone due to various monadic and proper-usage restrictions, some of which cannot be enforced statically. Previous work therefore suggests that self-adjusting computation would benefit from direct language and compiler support. In this paper, we propose a language-based technique for writing and compiling self-adjusting programs from ordinary programs. To compile self-adjusting programs, we use a continuation-passing style (cps) transformation to automatically infer a conservative approximation of the dynamic data dependences. To prevent the inferred, approximate dependences from degrading the performance of change propagation, we generate memoized versions of cps functions that can reuse previous work even when they are invoked with different continuations. The approach offers a natural programming style that requires minimal changes to existing code, while statically enforcing the invariants required by self-adjusting computation. We validate the feasibility of our proposal by extending Standard ML and by integrating the transformation into MLton, a whole-program optimizing compiler for Standard ML. Our experiments indicate that the proposed compilation technique can produce self-adjusting programs whose performance is consistent with the asymptotic bounds and experimental results obtained via manual rewriting (up to a constant factor).