Self-adjusting computation

Abstract

Many applications need to respond to incremental modifications to data. Being incremental, such modification often require incremental modifications to the output, making it possible to respond to them asymptotically faster than recomputing from scratch. In many cases, taking advantage of incrementality therefore dramatically improves performance, especially as the input size increases. As a frame of reference, note that in parallel computing speedups are bounded by the number of processors, often a (small) constant.Designing and developing applications that respond to incremental modifications, however, is challenging: it often involves developing highly specific, complex algorithms. Self-adjusting computation offers a linguistic approach to this problem. In selfadjusting computation, programs respond automatically and efficiently to modifications to their data by tracking the dynamic data dependences of the computation and incrementally updating their output as needed. In this invited talk, I present an overview of self-adjusting computation and briefly discuss the progress in developing the approach and some recent advances.

Distributed Programming for the Cloud: Models, Challenges, and Analytics Engines

“…Self-adjusting computation [3,6,5,24,15] offers a solution to the incremental-computation problem by enabling any computation to respond to changes in its data by efficiently recomputing only the subcomputations that are affected by the changes. To this end, a self-adjusting computation tracks dependencies between the inputs and outputs of subcomputations, and, in incremental runs, only rebuilds subcomputations affected (transitively) by modified inputs.…”

“…Informally speaking, we call a computation stable when the set of subcomputations performed on similar input data sets themselves are similar, i.e., many of the subcomputations are in fact the same and thus can be re-used. For a more precise definition of stability, we refer the interested reader to the previous work [3,27].…”

“…There are several algorithms for a variety of problems that are designed for a dynamic input [3,16,21,35,20]. This body of work shows that dynamic algorithms can be more efficient than their conventional counterparts.…”

“…While earlier proposals [4] required program annotations for efficiency, recent results show that some of these annotations can be inferred by type systems [15]. Stability, one of the key concepts that we use in this paper was developed initially as an algorithmic analysis technique [3] and later as part of a cost semantics [27]. Self-adjusting computation has been shown to be effective for a wide variety of problems and has led to progress on and sometimes solutions to open problems in several domains including computational geometry, machine learning, and checking of data structural invariants (e.g., [36,8,5,37,9]).…”

“…Incoop extends the Hadoop open source implementation of the MapReduce paradigm to run unmodified MapReduce programs in an incremental way. The design and implementation of Incoop is inspired by recent advances on self-adjusting computation [3,6,5,24,15], which offers a solution to the problem of automatic incrementalization of programs, and draws on techniques developed in that line of work. The idea behind Incoop is to enable the programmer to incrementalize automatically existing MapReduce programs without the need to make any modifications to the code.…”