Fixing some space leaks with a garbage collector
Software—Practice & Experience
Projections for strictness analysis
Proc. of a conference on Functional programming languages and computer architecture
Garbage collection in an uncooperative environment
Software—Practice & Experience
Update analysis and the efficient implementation of functional aggregates
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
Compile-time garbage collection by sharing analysis
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
Guardians in a generation-based garbage collector
PLDI '93 Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation
Information Processing Letters
Garbage collection and local variable type-precision and liveness in Java virtual machines
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
The aggregate update problem in functional programming systems
POPL '85 Proceedings of the 12th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Efficiency of a Good But Not Linear Set Union Algorithm
Journal of the ACM (JACM)
Cheap eagerness: speculative evaluation in a lazy functional language
ICFP '00 Proceedings of the fifth ACM SIGPLAN international conference on Functional programming
Heap profiling for space-efficient Java
Proceedings of the ACM SIGPLAN 2001 conference on Programming language design and implementation
Bounding space usage of conservative garbage collectors
POPL '02 Proceedings of the 29th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Estimating the impact of heap liveness information on space consumption in Java
Proceedings of the 3rd international symposium on Memory management
POPL '77 Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Systematic design of program analysis frameworks
POPL '79 Proceedings of the 6th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Eager Haskell: resource-bounded execution yields efficient iteration
Proceedings of the 2002 ACM SIGPLAN workshop on Haskell
Destructors, finalizers, and synchronization
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Finalization in the Collector Interface
IWMM '92 Proceedings of the International Workshop on Memory Management
The Theory and Practice of Transforming Call-by-need into Call-by-value
Proceedings of the Fourth 'Colloque International sur la Programmation' on International Symposium on Programming
Stretching the Storage Manager: Weak Pointers and Stable Names in Haskell
IFL '99 Selected Papers from the 11th International Workshop on Implementation of Functional Languages
IFL '02 Selected Papers from the 13th International Workshop on Implementation of Functional Languages
Asynchronous Signals is Standard ML
Asynchronous Signals is Standard ML
Optimistic evaluation: an adaptive evaluation strategy for non-strict programs
ICFP '03 Proceedings of the eighth ACM SIGPLAN international conference on Functional programming
Oil and Water? High Performance Garbage Collection in Java with MMTk
Proceedings of the 26th International Conference on Software Engineering
The Implementation of Functional Programming Languages (Prentice-Hall International Series in Computer Science)
GC assertions: using the garbage collector to check heap properties
Proceedings of the 2008 ACM SIGPLAN workshop on Memory systems performance and correctness: held in conjunction with the Thirteenth International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS '08)
Memory management for self-adjusting computation
Proceedings of the 7th international symposium on Memory management
GC assertions: using the garbage collector to check heap properties
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
| Hi-index | 0.00 |
We introduce a method for providing lightweight daemons, called simplifiers, that attach themselves to program data. If a data item has a simplifier, the simplifier may be run automatically from time to time, seeking an opportunity to "simplify" the object in some way that improves the program's time or space performance.It is not uncommon for programs to improve their data structures as they traverse them, but these improvements must wait until such a traversal occurs. Simplifiers provide an alternative mechanism for making improvements that is not tied to the vagaries of normal control flow.Tracing garbage collectors can both support the simplifier abstraction and benefit from it. Because tracing collectors traverse program data structures, they can trigger simplifiers as part of the tracing process. (In fact, it is possible to view simplifiers as analogous to finalizers; whereas an object can have a finalizer that is run automatically when the object found to be dead, a simplifier can be run when the object is found to be live.)Simplifiers can aid efficient collection by simplifying objects before they are traced, thereby eliminating some data that would otherwise have been traced and saved by the collector. We present performance data to show that appropriately chosen simplifiers can lead to tangible space and speed benefits in practice.Different variations of simplifiers are possible, depending on the triggering mechanism and the synchronization policy. Some kinds of simplifier are already in use in mainstream systems in the form of ad-hoc garbage-collector extensions. For one kind of simplifier we include a complete and portable Java implementation that is less than thirty lines long.