Memory management for self-adjusting computation

Abstract

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.

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.…”

“…[35]). Recent advances on selfadjusting computation propose general-purpose techniques that can achieve optimal update times (e.g., [6,5,24]). Self-adjusting computation offers abstractions for automatic incrementalization, allowing programs written in a conventional style to be compiled to programs that can respond to changes in their data inputs automatically.…”

“…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.…”

Non-monotonic Self-Adjusting Computation

“…The first was a pure higher-order language with a modal type system that was implemented both as a Standard ML library with a monad and explicit destination-passing [2] and a Haskell library using several monads to enforce the modal constraints [6]. Subsequent proposals included a direct-style higher-order language compiled into a continuation-passing style (CPS) higherorder language implemented in the MLton Standard ML compiler [13], and a low-level imperative language implemented as a compiler for C [10]. 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.…”

Refinement Types for Incremental Computational Complexity

“…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]. Several flavors of self-adjusting computation have been implemented in programming languages such as C [19], Haskell [8], Java [34] and Standard ML [27,10].…”