Space overhead bounds for dynamic memory management with partial compaction

ABSTRACT

Dynamic memory allocation is ubiquitous in today's runtime environments. Allocation and de-allocation of objects during program execution may cause fragmentation and foil the program's ability to allocate objects. Robson has shown that a worst case scenario can create a space overhead within a factor of log(n) of the space that is actually required by the program, where n is the size of the largest possible object. Compaction can eliminate fragmentation, but is too costly to be run frequently. Many runtime systems employ partial compaction, in which only a small fraction of the allocated objects are moved. Partial compaction reduces some of the existing fragmentation at an acceptable cost. In this paper we study the effectiveness of partial compaction and provide the first rigorous lower and upper bounds on its effectiveness in reducing fragmentation at a low cost.

References

1. Diab Abuaiadh, Yoav Ossia, Erez Petrank, and Uri Silbershtein. An efficient parallel heap compaction algorithm. In Proceedings of the Nineteenth ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, ACM SIGPLAN Notices 39(10), pages 224--236, Vancouver, Canada, October 2004.
2. David F. Bacon, Perry Cheng, and V.T. Rajan. A real-time garbage collector with low overhead and consistent utilization. In Conference Record of the Thirtieth Annual ACM Symposium on Principles of Programming Languages, ACM SIGPLAN Notices 38(1), pages 285--298, New Orleans, LA, USA, January 2003.
3. Ori Ben-Yitzhak, Irit Goft, Elliot Kolodner, Kean Kuiper, and Victor Leikehman. An algorithm for parallel incremental compaction. In Hans-J. Boehm and David Detlefs, editors, Proceedings of the Third International Symposium on Memory Management (June, 2002), ACM SIGPLAN Notices 38(2 supplement), pages 100--105, Berlin, Germany, February 2003.
4. Anna Bendersky and Erez Petrank. Space overhead bounds for dynamic memory management with partial compaction. A full version of this paper is available at http://www.cs.technion.ac.il/ erez/papers.html, 2010.
5. Hans-Juergen Boehm. Bounding space usage of conservative garbage collectors. In POPL 2002 {16}, pages 93--100.
6. Hans-Juergen Boehm. The space cost of lazy reference counting. In Proceedings of the Thirty-First Annual ACM Symposium on Principles of Programming Languages, ACM SIGPLAN Notices 39(1), pages 210--219, Venice, Italy, January 2004.
7. Hans-Juergen Boehm and Mark Weiser. Garbage collection in an uncooperative environment. Software Practice and Experience, 18(9):807--820, 1988.
8. Cliff Click, Gil Tene, and MichaelWolf. The Pauseless GC algorithm. In Michael Hind and Jan Vitek, editors, Proceedings of the First ACM SIGPLAN/SIGOPS International Conference on Virtual Execution Environments, pages 46--56, Chicago, IL, USA, June 2005.
9. David Detlefs, Christine Flood, Steven Heller, and Tony Printezis. Garbage-first garbage collection. In David F. Bacon and Amer Diwan, editors, Proceedings of the Fourth International Symposium on Memory Management, pages 37--48, Vancouver, Canada, October 2004. ACM Press.
10. Tamar Domani, Elliot K. Kolodner, Ethan Lewis, Elliot E. Salant, Katherine Barabash, Itai Lahan, Erez Petrank, Igor Yanover, and Yossi Levanoni. Implementing an on-the-fly garbage collector for Java. In Craig Chambers and Antony L. Hosking, editors, Proceedings of the Second International Symposium on Memory Management, ACM SIGPLAN Notices 36(1), pages 155--166, Minneapolis, MN, October 2000.
11. Richard E. Jones. Garbage Collection: Algorithms for Automatic Dynamic Memory Management. Wiley, Chichester, July 1996. With a chapter on Distributed Garbage Collection by R. Lins.
12. Haim Kermany and Erez Petrank. The Compressor: Concurrent, incremental and parallel compaction. In Michael I. Schwartzbach and Thomas Ball, editors, Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation, ACM SIGPLAN Notices 41(6), pages 354--363, Ottawa, Canada, June 2006.
13. Erez Petrank and Dror Rawitz. The hardness of cache conscious data placement. In POPL 2002 {16}, pages 101--112.
14. Filip Pizlo, Daniel Frampton, Erez Petrank, and Bjarne Steensgard. STOPLESS: A real-time garbage collector for multiprocessors. In Greg Morrisett and Mooly Sagiv, editors, Proceedings of the Sixth International Symposium on Memory Management, pages 159--172, Montr´eal, Canada, October 2007. ACM Press.
15. Filip Pizlo, Erez Petrank, and Bjarne Steensgaard. A study of concurrent real-time garbage collectors. In Rajiv Gupta and Saman P. Amarasinghe, editors, Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation, ACM SIGPLAN Notices 43(6), pages 33--44, Tucson, AZ, USA, June 2008.
16. Conference Record of the Twenty-ninth Annual ACM Symposium on Principles of Programming Languages, ACM SIGPLAN Notices 37(1), Portland, OR, USA, January 2002.
17. J. M. Robson. An estimate of the store size necessary for dynamic storage allocation. Journal of the ACM, 18(3):416--423, July 1971.
18. J. M. Robson. Bounds for some functions concerning dynamic storage allocation. Journal of the ACM, 21(3):419--499, July 1974.

Index Terms

• Software and its engineering

  • Software notations and tools

    • Compilers

      • Dynamic compilers

  • Software organization and properties

    • Contextual software domains

      • Operating systems

        • Memory management

          • Garbage collection