Self-adjusting binary search trees
Journal of the ACM (JACM)
The ultimate planar convex hull algorithm
SIAM Journal on Computing
Two algorithms for maintaining order in a list
STOC '87 Proceedings of the nineteenth annual ACM symposium on Theory of computing
Incremental graph evaluation (attribute grammar)
Incremental graph evaluation (attribute grammar)
Readings in nonmonotonic reasoning
A data structure for dynamic trees
Journal of Computer and System Sciences
Incremental computation via function caching
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Incremental reduction in the lambda calculus
LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
INC: a language for incremental computations
ACM Transactions on Programming Languages and Systems (TOPLAS)
Incremental reduction in the lambda calculus and related reduction systems
Incremental reduction in the lambda calculus and related reduction systems
Dynamic expression trees and their applications
SODA '91 Proceedings of the second annual ACM-SIAM symposium on Discrete algorithms
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)
Garbage collection: algorithms for automatic dynamic memory management
Garbage collection: algorithms for automatic dynamic memory management
A data structure for dynamically maintaining rooted trees
Journal of Algorithms
Dynamic trees as search trees via Euler tours, applied to the network simplex algorithm
Mathematical Programming: Series A and B
Sparsification—a technique for speeding up dynamic graph algorithms
Journal of the ACM (JACM)
The art of computer programming, volume 3: (2nd ed.) sorting and searching
The art of computer programming, volume 3: (2nd ed.) sorting and searching
Algorithmic geometry
Static caching for incremental computation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Implementation of dynamic trees with in-subtree operations
Journal of Experimental Algorithmics (JEA)
Kinetic data structures: a state of the art report
WAFR '98 Proceedings of the third workshop on the algorithmic foundations of robotics on Robotics : the algorithmic perspective: the algorithmic perspective
Data structures for mobile data
Journal of Algorithms
Randomized fully dynamic graph algorithms with polylogarithmic time per operation
Journal of the ACM (JACM)
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
Optimal-time incremental semantic analysis for syntax-directed editors
POPL '82 Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Algorithmic issues in modeling motion
ACM Computing Surveys (CSUR)
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Minimizing Diameters of Dynamic Trees
ICALP '97 Proceedings of the 24th International Colloquium on Automata, Languages and Programming
Maintaining Minimum Spanning Trees in Dynamic Graphs
ICALP '97 Proceedings of the 24th International Colloquium on Automata, Languages and Programming
Two Simplified Algorithms for Maintaining Order in a List
ESA '02 Proceedings of the 10th Annual European Symposium on Algorithms
FOCS '02 Proceedings of the 43rd Symposium on Foundations of Computer Science
Dynamic Planar Convex Hull Operations in Near-Logarithmic Amortized Time
FOCS '99 Proceedings of the 40th Annual Symposium on Foundations of Computer Science
Computational geometry.
Dynamizing static algorithms, with applications to dynamic trees and history independence
SODA '04 Proceedings of the fifteenth annual ACM-SIAM symposium on Discrete algorithms
An empirical comparison of techniques for updating Delaunay triangulations
SCG '04 Proceedings of the twentieth annual symposium on Computational geometry
SODA '05 Proceedings of the sixteenth annual ACM-SIAM symposium on Discrete algorithms
Self-adjusting computation
Maintaining information in fully dynamic trees with top trees
ACM Transactions on Algorithms (TALG)
An experimental analysis of self-adjusting computation
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Adaptive functional programming
ACM Transactions on Programming Languages and Systems (TOPLAS)
A package for exact kinetic data structures and sweepline algorithms
Computational Geometry: Theory and Applications
DITTO: automatic incrementalization of data structure invariant checks (in Java)
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Kinetic data structures in practice
Kinetic data structures in practice
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
Transforming static data structures to dynamic structures
SFCS '79 Proceedings of the 20th Annual Symposium on Foundations of Computer Science
New classes and applications of hash functions
SFCS '79 Proceedings of the 20th Annual Symposium on Foundations of Computer Science
Compiling self-adjusting programs with continuations
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
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
A Library for Self-Adjusting Computation
Electronic Notes in Theoretical Computer Science (ENTCS)
A consistent semantics of self-adjusting computation
ESOP'07 Proceedings of the 16th European conference on Programming
WEA'07 Proceedings of the 6th international conference on Experimental algorithms
Kinetic and dynamic data structures for convex hulls and upper envelopes
WADS'05 Proceedings of the 9th international conference on Algorithms and Data Structures
Traceable data types for self-adjusting computation
PLDI '10 Proceedings of the 2010 ACM SIGPLAN conference on Programming language design and implementation
Proceedings of the twenty-seventh annual symposium on Computational geometry
Implicit self-adjusting computation for purely functional programs
Proceedings of the 16th ACM SIGPLAN international conference on Functional programming
Incoop: MapReduce for incremental computations
Proceedings of the 2nd ACM Symposium on Cloud Computing
Two for the price of one: a model for parallel and incremental computation
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
Adaptive Exact Inference in Graphical Models
The Journal of Machine Learning Research
Type-directed automatic incrementalization
Proceedings of the 33rd ACM SIGPLAN conference on Programming Language Design and Implementation
Streaming big data with self-adjusting computation
DDFP '13 Proceedings of the 2013 workshop on Data driven functional programming
Exploring optimization and caching for efficient collection operations
Automated Software Engineering
Hi-index | 0.00 |
Recent work on adaptive functional programming (AFP) developed techniques for writing programs that can respond to modifications to their data by performing change propagation. To achieve this, executions of programs are represented with dynamic dependence graphs (DDGs) that record data dependences and control dependences in a way that a change-propagation algorithm can update the computation as if the program were from scratch, by re-executing only the parts of the computation affected by the changes. Since change-propagation only re-executes parts of the computation, it can respond to certain incremental modifications asymptotically faster than recomputing from scratch, potentially offering significant speedups. Such asymptotic speedups, however, are rare: for many computations and modifications, change propagation is no faster than recomputing from scratch. In this article, we realize a duality between dynamic dependence graphs and memoization, and combine them to give a change-propagation algorithm that can dramatically increase computation reuse. The key idea is to use DDGs to identify and re-execute the parts of the computation that are affected by modifications, while using memoization to identify the parts of the computation that remain unaffected by the changes. We refer to this approach as self-adjusting computation. Since DDGs are imperative, but (traditional) memoization requires purely functional computation, reusing computation correctly via memoization becomes a challenge. We overcome this challenge with a technique for remembering and reusing not just the results of function calls (as in conventional memoization), but their executions represented with DDGs. We show that the proposed approach is realistic by describing a library for self-adjusting computation, presenting efficient algorithms for realizing the library, and describing and evaluating an implementation. Our experimental evaluation with a variety of applications, ranging from simple list primitives to more sophisticated computational geometry algorithms, shows that the approach is effective in practice: compared to recomputing from-scratch; self-adjusting programs respond to small modifications to their data orders of magnitude faster.