Incremental computation via function caching

Pugh, William; Teitelbaum, Tim

doi:10.1145/75277.75305

Cited by 149 publications

(99 citation statements)

References 12 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…All of these designs focus on strict languages with call-by-value (CBV) functions that eagerly evaluate function arguments 7 and none of them supported efficient reordering. Approaches based on pure memoization (function caching) alone [16,14] allow for incrementality with reordering; since they lack the fine-grained dependence tracking of modifiable references, they can only provide coarse-grained reuse and are inefficient for deeply-nested changes (e.g., changing the last element of a list). Previous work introduced a cost semantics for self-adjusting computation with updatable references and monotonic reuse, and showed analogous correctness properties of change-propagation and compilation [12].…”

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

Non-monotonic Self-Adjusting Computation

Ley-Wild

Acar

Blelloch

2012

Programming Languages and Systems

View full text Add to dashboard Cite

Abstract. Self-adjusting computation is a language-based approach to writing programs that respond dynamically to input changes by maintaining a trace of the computation consistent with the input, thus also updating the output. For monotonic programs, i.e. where localized input changes cause localized changes in the computation, the trace can be repaired efficiently by insertions and deletions. However, non-local input changes that are can cause major reordering of the trace. In such cases, updating the trace can be asymptotically equal to running from scratch. In this paper, we eliminate the monotonicity restriction by generalizing the update mechanism to use trace slices, which are partial fragments of the computation that can be reordered with some bookkeeping. We provide a high-level source language for pure programs, equipped with a notion of trace distance for comparing two runs of a program modulo reordering. The source language is translated into a low-level target language with intrinsic support for non-monotonic update (i.e., with reordering). We show that the translation asymptotically preserves the semantics and trace distance, that the cost of update coincides with trace distance, and that updating produces the same answer as a fromscratch run. We describe a concrete algorithm for implementing changepropagation with asymptotic bounds on running time. The concrete algorithm achieves running time bounds which are within O(log n) of the trace distance, where n is the trace length.

show abstract

Section: Related Workmentioning

confidence: 99%

“…Programming languages for incremental computation provide compile-and run-time support to (semi-)automatically derive incremental programs from static programs [8,16,17]. In particular, self-adjusting computation (SAC) is a languagebased approach that provides a general-purpose change-propagation mechanism to update the output [1].…”

Section: Introductionmentioning

confidence: 99%

Non-monotonic Self-Adjusting Computation

Ley-Wild

Acar

Blelloch

2012

Programming Languages and Systems

View full text Add to dashboard Cite

show abstract

“…The general concept of memoization in computer programs has been around for a long time where the idea is to speed up the computer programs by avoiding repetitive/redundant function calls [9] [10] [11]. Nevertheless, in practice, the general notion of memoization has not gained success due to the following reasons: 1) the proposed techniques usually require detailed profiling information about the runtime behaviour of the program which makes it difficult to implement [12], 2) the techniques are usually generic methods which do not concentrate on any particular class of input data or algorithms [13], and 3) the memoization engine used by these techniques are based on non-fuzzy comparison where two input data is considered equal (in which case one's result can be reused for another) if they are identical.…”

Section: Window Memoizationmentioning

confidence: 99%

Cascaded Window Memoization for Medical Imaging

Khalvati

Kianpour

Tizhoosh

2011

IFIP Advances in Information and Communication Technology

View full text Add to dashboard Cite

Abstract. Window Memoization is a performance improvement technique for image processing algorithms. It is based on removing computational redundancy in an algorithm applied to a single image, which is inherited from data redundancy in the image. The technique employs a fuzzy reuse mechanism to eliminate unnecessary computations. This paper extends the window memoization technique such that in addition to exploiting the data redundancy in a single image, the data redundancy in a sequence of images of a volume data is also exploited. The detection of the additional data redundancy leads to higher speedups. The cascaded window memoization technique was applied to Canny edge detection algorithm where the volume data of prostate MR images were used. The typical speedup factor achieved by cascaded window memoization is 4.35x which is 0.93x higher than that of window memoization.

show abstract

“…The field of incremental computation aims at deriving software that can respond automatically and efficiently to changing data. Earlier work investigated techniques based on static dependency graphs [14,38] and memoization [32,21]. More recent work on self-adjusting computation introduced dynamic dependency graphs [3] and a way to integrate them with a form of memoization [2,4].…”

Section: Introductionmentioning

confidence: 99%

Refinement Types for Incremental Computational Complexity

Çiçek

Garg

Acar

2015

Programming Languages and Systems

View full text Add to dashboard Cite

Abstract. With recent advances, programs can be compiled to efficiently respond to incremental input changes. However, there is no language-level support for reasoning about the time complexity of incremental updates. Motivated by this gap, we present CostIt, a higher-order functional language with a lightweight refinement type system for proving asymptotic bounds on incremental computation time. Type refinements specify which parts of inputs and outputs may change, as well as dynamic stability, a measure of time required to propagate changes to a program's execution trace, given modified inputs. We prove our type system sound using a new step-indexed cost semantics for change propagation and demonstrate the precision and generality of our technique through examples.

show abstract

Incremental computation via function caching

Cited by 149 publications

References 12 publications

Non-monotonic Self-Adjusting Computation

Non-monotonic Self-Adjusting Computation

Cascaded Window Memoization for Medical Imaging

Refinement Types for Incremental Computational Complexity

Contact Info

Product

Resources

About