Two algorithms for maintaining order in a list
STOC '87 Proceedings of the nineteenth annual ACM symposium on Theory of computing
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)
A categorized bibliography on incremental computation
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The measured cost of conservative garbage collection
Software—Practice & Experience
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)
Region-based memory management
Information and Computation
Static caching for incremental computation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Caching function calls using precise dependencies
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
Garbage Collection of Linked Data Structures
ACM Computing Surveys (CSUR)
List processing in real time on a serial computer
Communications of the ACM
Recursive functions of symbolic expressions and their computation by machine, Part I
Communications of the ACM
A method for overlapping and erasure of lists
Communications of the ACM
Combining region inference and garbage collection
PLDI '02 Proceedings of the ACM SIGPLAN 2002 Conference on Programming language design and implementation
Region-based memory management in cyclone
PLDI '02 Proceedings of the ACM SIGPLAN 2002 Conference on Programming language design and implementation
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
Reconsidering custom memory allocation
OOPSLA '02 Proceedings of the 17th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Uniprocessor Garbage Collection Techniques
IWMM '92 Proceedings of the International Workshop on Memory Management
Dynamic Programming
Memory Subsystem Performance of Programs with Intensive Heap Allocation
Memory Subsystem Performance of Programs with Intensive Heap Allocation
A Retrospective on Region-Based Memory Management
Higher-Order and Symbolic Computation
Self-adjusting computation
An experimental analysis of self-adjusting computation
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Whole-program compilation in MLton
Proceedings of the 2006 workshop on ML
Smarter garbage collection with simplifiers
Proceedings of the 2006 workshop on Memory system performance and correctness
Adaptive functional programming
ACM Transactions on Programming Languages and Systems (TOPLAS)
Kinetic 3D convex hulls via self-adjusting computation
SCG '07 Proceedings of the twenty-third annual symposium on Computational geometry
DITTO: automatic incrementalization of data structure invariant checks (in Java)
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Kinetic algorithms via self-adjusting computation
ESA'06 Proceedings of the 14th conference on Annual European Symposium - Volume 14
Imperative self-adjusting computation
Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Dynamic mesh refinement
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
An experimental analysis of self-adjusting computation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Self-adjusting computation with Delta ML
AFP'08 Proceedings of the 6th international conference on Advanced functional programming
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
Type-directed automatic incrementalization
Proceedings of the 33rd ACM SIGPLAN conference on Programming Language Design and Implementation
Hi-index | 0.00 |
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 self-adjusting 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.