An experimental analysis of self-adjusting computation

Acar, Umut A.; Blelloch, Guy E.; Blume, M.; Tangwongsan, Kanat

doi:10.1145/1133255.1133993

Cited by 25 publications

(68 citation statements)

References 24 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The first two extensions simplify the interface and reduce the potential for errors. The third extension avoids the need for higher-order "lift" operators required in the previous work [4].…”

Section: Our Contributionsmentioning

confidence: 99%

“…These include benchmarks used in the previous work [4] plus additional computational-geometry and tree applications. We compare our library to the most current implementation of self-adjusting computation, which is in Standard ML.…”

Section: Our Contributionsmentioning

confidence: 99%

“…Automatic incrementalization concerns the transformation of programs into incremental programs that can respond to changes to their input data efficiently (e.g., [15,31], for a survey see [32]). Recent work on self-adjusting computation (e.g., [4]) broadened the applicability and efficiency of automatic incrementalization. The approach has been applied to a number of applications including invariant checking and program verification [33], motion simulation [6,7], machine learning [8], and scientific computing [22].…”

Section: Introductionmentioning

confidence: 99%

“…Detailed practical evaluations of self-adjusting computation show that garbage collection can be a significant cost [4]. As an example, Figure 1 shows timings for from-scratch runs and change propagation of a self-adjusting program.…”

Section: Introductionmentioning

confidence: 99%

See 3 more Smart Citations

Memory management for self-adjusting computation

Hammer

Acar

2008

Proceedings of the 7th International Symposium on Memory Management

Self Cite

View full text Add to dashboard Cite

The cost of reclaiming space with traversal-based garbage collection is inversely proportional to the amount of free memory, i.e., O(1/(1 − f )), where f is the fraction of memory that is live. Consequently, the cost of garbage collection can be very high when the size of the live data remains large relative to the available free space. Intuitively, this is because allocating a small amount of memory space will require the garbage collector to traverse a significant fraction of the memory only to discover little garbage. This is unfortunate because in some application domains the size of the memory-resident data can be generally high. This can cause high GC overheads, especially when generational assumptions do not hold. One such application domain is self-adjusting computation, where computations use memory-resident execution traces in order to respond to changes to their state (e.g., inputs) efficiently.This paper proposes memory-management techniques for selfadjusting computation that remain efficient even when the size of the live data is large. More precisely, the proposed techniques guarantee O(1) amortized cost for each reclaimed memory object. We propose a set of primitives for self-adjusting computation that support the proposed memory management techniques. The primitives provide an operation for allocating memory; we reclaim unused memory automatically.We implement a library for supporting the primitives in the C language and perform an experimental evaluation. Our experiments show that the approach can be implemented with reasonably small constant-factor overheads and that the programs written using the library behave optimally. Compared to previous implementations, we measure up to an order of magnitude improvement in performance and up to a 75% reduction in space usage.

show abstract

Section: Our Contributionsmentioning

confidence: 99%

Section: Our Contributionsmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Memory management for self-adjusting computation

Hammer

Acar

2008

Proceedings of the 7th International Symposium on Memory Management

Self Cite

View full text Add to dashboard Cite

show abstract

“…Inspired by advances on self-adjusting computation [10,11], this work [5] proposes an extension to Hadoop with a content-based grouping used to detect the changes in input file. Another set of related work is from the overload management issues in distributed stream processing system.…”

Section: Related Workmentioning

confidence: 99%

Fault tolerant state management for high-volume low-latency data stream workloads

Muralidharan

Kumar

Bhasi

2014

2014 International Conference on Data Science &Amp; Engineering (ICDSE)

View full text Add to dashboard Cite

One of the major challenges in performing incremental computations on parallel distributed stream processing systems is in the implementation of a mechanism for passing state values across successive runs. One approach is to enhance the granularity from record-at-a-time processing to processing at micro-batch level. A contrasting approach is to follow the record-at-a-time semantics and ensure scalability by means of distributed state management. Both approaches, however, require observing high degree of fault tolerance. In this paper, we study the problem of process state management against non-terminating data stream workloads for low-latency computing using the micro-batch stream processing approach. We attempt to examine methods that could yield optimum levels of state retentions with high degree of fault tolerance for typical processing workloads and propose a three-pronged approach to harness the demand.

show abstract

A consistent semantics of self-adjusting computation

Acar¹,

Blume²,

Donham³

2013

J. Funct. Prog.

Self Cite

View full text Add to dashboard Cite

This paper presents a semantics of self-adjusting computation and proves that the semantics are correct and consistent. The semantics integrate change propagation with the classic idea of memoization to enable reuse of computations under mutation to memory. During evaluation, reuse of a computation via memoization triggers a change propagation that adjusts the reused computation to reflect the mutated memory. Since the semantics integrate memoization and change-propagation, it involves both non-determinism (due to memoization) and mutation (due to change propagation). Our consistency theorem states that the non-determinism is not harmful: any two evaluations of the same program starting at the same state yield the same result. Our correctness theorem states that mutation is not harmful: self-adjusting programs are consistent with purely functional programming. We formalize the semantics and their meta-theory in the LF logical framework and machine check our proofs using Twelf. IntroductionMany applications operate on data that changes over time. Self-adjusting computation is a technique that enables program to respond to changes to their data (e.g., inputs/arguments, external state, or outcome of tests). Advances on self-adjusting computation show that it can speed up response times by orders of magnitude over recomputing from scratch, closely matching best-known (problem-specific) algorithms both in theory and in practice (e.g., [3]). More recent results show that the approach can even enable solving challenging open problems that have resisted traditional algorithmic approaches (e.g. [7,6]).Key to effectiveness of self-adjusting computation is a technique that integrates change propagation [4], and the classic idea of memoization [17]. Due to an interesting duality between memoization and change propagation, combining them turns out to be crucial for efficiency. This technique was first developed in two previously published conference papers. One paper focused on algorithmic, implementation, and experimental aspects (journal version [3]). The other formal *

show abstract

An experimental analysis of self-adjusting computation

Cited by 25 publications

References 24 publications

Memory management for self-adjusting computation

Memory management for self-adjusting computation

Fault tolerant state management for high-volume low-latency data stream workloads

A consistent semantics of self-adjusting computation

Contact Info

Product

Resources

About