Academia.eduAcademia.edu

Outline

Title
Abstract
Magic Methods
Testbed Futures
Ü4.5 Summary
Background
Limitations
Introduction
Results
Ü8.3 Results
Summary
Conclusion 10.1 Contribution of This Thesis
Conclusion
Future Work
References
All Topics
Computer Science
Operating Systems

JMTK: a portable memory management toolkit

Profile image of Robin GarnerRobin Garner

2003

Abstract
sparkles

AI

JMTK is a portable memory management toolkit designed to provide basic building blocks for garbage collection and memory management systems, facilitating comparisons of various garbage collection algorithms across different programming language environments. This implementation highlights the importance of overcoming the challenges associated with memory management, especially given the performance discrepancies observed in high-level languages such as Java and Haskell. The toolkit enables a refined understanding of performance characteristics and aims to adapt memory management practices for evolving computational technologies.

Related papers

A Comparative Study of Garbage Collection Techniques in Java Virtual Machines
Sajid Iqbal

Garbage collection mechanisms implemented in Java Virtual Machines (JVMs) are used to reclaim memory allocated to the objects that become inaccessible during program execution. An efficient garbage collection mechanism certainly facilitates in smooth running of an application. This paper performs a comparative analysis of garbage collection techniques implemented in Sun HotSpot, Oracle JRockit and IBM J9 virtual machines. We perform experiments with several benchmarks containing dynamic creation for objects of TreeMap, ArrayList and String array data types. Due to the creation of a large number of big sized memory objects and loss of references, the garbage is created that is collected by the garbage collectors implemented in the virtual machines. The experiments are carried out on different hardware architectures including Intel Core 2 Quad and Intel Xeon based systems. The performance of each garbage collector is computed in terms of the rate of garbage collection that mainly depends upon the strategy implemented for garbage collection. Our results show that the Sun HotSpot garbage collector performs 4.66 times better than the Oracle JRockit and 144.06 times better than the IBM J9 garbage collectors.

View PDFchevron_right
Garbage Collection Evaluation Infrastructure for the Cog VM
Eliot Miranda

2018

One of the next steps to improve Cog, the default virtual machine for multiple programming languages in the Smalltalk family, such as Pharo, Squeak and Newspeak, is to decrease garbage collection pause times. Reference garbage collection algorithm implementations and a benchmarking infrastructure are required to evaluate the performance of a new algorithm and compare it. Cog features a Mark-Compact algorithm, used in production, to which we added a Mark-Sweep algorithm, providing two reference algorithms. Benchmarks are built using two different approaches. Firstly, we turned code from memory intensive deployed applications into benchmarks to simulate real-world applications. Secondly, we built a configurable benchmark which simulates an application with different heap properties to be able to stress specific aspects of the memory management. We then evaluated the two reference algorithms on the infrastructure built to obtain reference benchmark results.

View PDFchevron_right
Towards an Efficient Benchmark Generation Engine for Garbage Collection
OMAR PORTILLO

ACM/SPEC International Conference on Performance Engineering, 2018

Garbage Collection (GC) is a key feature of many modern programming technologies. It offers significant software engineering benefits over explicitly memory management. Nonetheless, it is also a major cause of performance degradation. As the rate of adoption of GC-related technologies continues to grow, it is highly relevant to understand its performance impact. However, this is challenging due to the non-deterministic nature of GC. To tackle this problem, we present an engine (HERMES) to create realistic GC benchmarks by effectively capturing the GC/memory behaviours exhibited by real-world Java applications. Our experiments prove how HERMES can be useful to strengthen the evaluation of GC-related advancements. This is achieved by broadening the number and diversity of the test scenarios, as well as reducing the time invested in testing.

View PDFchevron_right
Accurate garbage collection in uncooperative environments revisited
Jan Vitek

Concurrency and Computation: Practice and Experience, 2009

Implementing a concurrent programming language such as Java by means of a translator to an existing language is attractive as it provides portability over all platforms supported by the host language and reduces development time-as many low-level tasks can be delegated to the host compiler. The C and C++ programming languages are popular choices for many language implementations due to the availability of efficient compilers on a wide range of platforms. For garbage-collected languages, however, they are not a perfect match as no support is provided for accurately discovering pointers to heap-allocated data on thread stacks. We evaluate several previously published techniques and propose a new mechanism, lazy pointer stacks, for performing accurate garbage collection in such uncooperative environments. We implemented the new technique in the Ovm Java virtual machine with our own Java-to-C/C++ compiler using GCC as a back-end compiler. Our extensive experimental results confirm that lazy pointer stacks outperform existing approaches: we provide a speedup of 4.5% over Henderson's accurate collector with a 17% increase in code size. Accurate collection is essential in the context of real-time systems, we thus validate our approach with the implementation of a real-time concurrent garbage collection algorithm.

View PDFchevron_right
Improving the Testing of Java Garbage Collection Through an Efficient Benchmark Generation
OMAR PORTILLO

International Conference in Software Engineering Research and Innovation (CONISOFT), 2018

Garbage Collection (GC) is a core feature of multiple modern technologies (e.g., Java, Android). On one hand, it offers significant software engineering benefits over explicitly memory management, like preventing most types of memory leaks. On the other hand, GC is a known cause of performance degradation. However, it is considerably challenging to understand its exact impact on the overall application performance. This is because the non-deterministic nature of GC makes very complex to properly model it and evaluate its performance impacts. To help tackling these problems, we present an engine to generate realistic GC benchmarks by enabling to effectively capture the GC/memory behaviours experienced by real-world Java applications. We also demonstrate, through a comprehensive experimental evaluation, how such benchmarks can be useful to strengthen the evaluation of GC-related advancements.

View PDFchevron_right
Older-first garbage collection in practice: Evaluation in a Java virtual machine
Darko Stefanovic

ACM SIGPLAN …, 2002

Until recently, the best performing copying garbage collectors used a generational policy which repeatedly collects the very youngest objects, copies any survivors to an older space, and then infrequently collects the older space. A previous study that used garbage-collection simulation pointed to potential improvements by using an Older-First copying garbage collection algorithm. The Older-First algorithm sweeps a fixed-sized window through the heap from older to younger objects, and avoids copying the very youngest ...

View PDFchevron_right
Selection, Initialization and Activation of Application Specific Garbage Collector: SpecJVM2008
Nitan Singh

Different applications written in java are suitable to execute with different garbage collectors (GC's). In the current scenario the selection of a garbage collector depends on machine architecture and operating system. Serial collector is invoked for most of the application running on client class and parallel collector is invoked for applications running on server class. In this research paper we have proposed a solution for the intelligent selection and activation of garbage collector with appropriate parameters for finding the optimal performance for each benchmark of SPECjvm2008. The parameter settings which we have obtained after testing and analysis of data are used to decide the heap size and the GC for the benchmark. That setting would give optimal and best performance for that particular benchmark. The proposed model achieves improvement of 2% in throughput and also reduced the execution time of the application by 7% as compared to the default collector. It can also be used for the real time application because of the improved performance by reducing the frequency of collection. Garbage collection time is also reduced by 39%. Number of times the application stopped due to garbage collection is also reduced. Memory reclamation after garbage collection is also increased.

View PDFchevron_right
A generational on-the-fly garbage collector for Java
Hillel Kolodner

ACM SIGPLAN Notices, 2000

An on-the-fly garbage collector does not stop the program threads to perform the collection. Instead, the collector executes in a separate thread (or process) in parallel to the program. On-the-fly collectors are useful for multi-threaded applications running on multiprocessor servers, where it is important to fully utilize all processors and provide even response time, especially for systems for which stopping the threads is a costly operation. In this work, we report on the incorporation of generations into an on-the-fly garbage collector. The incorporation is non-trivial since an on-the-fly collector avoids explicit synchronization with the program threads. To the best of our knowledge, such an incorporation has not been tried before. We have implemented the collector for a prototype Java Virtual Machine on AIX, and measured its performance on a 4-way multiprocessor. As for other generational collectors, an on-the-fly generational collector has the potential for reducing the over...

View PDFchevron_right
The garbage collection advantage
Eliot Moss

ACM SIGPLAN Notices, 2004

As improvements in processor speed continue to outpace improvements in cache and memory speed, poor locality increasingly degrades performance. Because copying garbage collectors move objects, they have an opportunity to improve locality. However, no static copying order is guaranteed to match program traversal orders. This paper introduces online object reordering (OOR) which includes a new dynamic, online class analysis for Java that detects program traversal patterns and exploits them in a copying collector. OOR uses run-time method sampling that drives just-in-time (JIT) compilation. For each hot (frequently executed) method, OOR analysis identifies the hot field accesses. At garbage collection time, the OOR collector then copies referents of hot fields together with their parent. Enhancements include static analysis to exclude accesses in cold basic blocks, heuristics that decay heat to respond to phase changes, and a separate space for hot objects. The overhead of OOR is on av...

View PDFchevron_right
Controlling garbage collection and heap growth to reduce the execution time of Java applications
Hang Pham

ACM Transactions on Programming Languages and Systems, 2006

In systems that support garbage collection a tension exists between collecting garbage too frequently and not collecting garbage frequently enough. Garbage collection that occurs too frequently may introduce unnecessary overheads at the risk of not collecting much garbage during each cycle. On the other hand, collecting garbage too infrequently can result in applications that execute with a large amount of virtual memory (i.e., with a large footprint) and suffer from increased execution times due to paging.

View PDFchevron_right

References (51)

  1. comparison between the same benchmarks running in different virtual ma- chines was made, which showed that the portable JMTk collectors in the testbed run- time are comparable in performance to other Java virtual machines and garbage col- lectors. Having evaluated the performance of the portable JMTk, the next chapter looks at the experience of performing a systems programming task in standard Java, while the final chapter draws some final conclusions from the work performed in this project. ALPERN, B., ATTANASIO, C. R., BARTON, J. J., COCCHI, A., HUMMEL, S. F., LIEBER, D., NGO, T., MERGEN, M. F., SHEPHERD, J. C., AND SMITH, S. 1999. Im- plementing Jalape ño in Java. In Proceedings of the 1999 ACM Conference on Object- Oriented Programming Systems, Languages and Applications (OOPSLA '99) (1999), pp. 314-324. (p. 16)
  2. ALPERN, B., ATTANASIO, C. R., BARTON, J. J., COCCHI, A., HUMMEL, S. F., LIEBER, D., NGO, T., MERGEN, M. F., SHEPHERD, J. C., AND SMITH, S. 2000. The Jalape ño virtual machine. IBM System Journal 39, 1 (Feb.), 211-238. (p. 16)
  3. APPEL, A. W. 1989. Simple generational garbage collection and fast allocation. Software-Practice and Experience 19, 171-183. (pp. 12, 54)
  4. ATTANASIO, C. R., BACON, D. F., COCCHI, A., AND SMITH, S. E. 2001. A com- parative evaluation of parallel garbage collectors. In Proceedings of the Fourteenth Annual Workshop on Languages and Compilers for Parallel Computing, Lecture Notes in Computer Science (June 2001). Springer-Verlag. Forthcoming. (p. 11)
  5. AUGUSTSSON, L. 1984. A compiler for lazy ml. In Proc. ACM Symposium on Lisp and Functional Programming (1984). (pp. 18, 47)
  6. BARTLETT, J. F. 1988. Compacting garbage collection with ambiguous roots. Tech- nical Report 88/2, DEC WRL. (p. 12)
  7. BERSHAD, B. N., CHAMBERS, C., EGGERS, S. J., MAEDA, C., MCNAMEE, D., PARDYAK, P., SAVAGE, S., AND SIRER, E. G. 1994. SPIN -an extensible micro- kernel for application-specific operating system services. In ACM SIGOPS European Workshop (1994), pp. 68-71. (p. 74)
  8. BLACKBURN, S. M., CHENG, P., AND MCKINLEY, K. S. 2004a. Myths and real- ities: The performance impact of garbage collection. In Submitted for Publication to SIGMETRICS (2004). http://www.cs.utexas.edu/users/mckinley/papers/jmtk- sigmetrics-submit-2003.ps.g z. (pp. 13, 15, 62, 67)
  9. BLACKBURN, S. M., CHENG, P., AND MCKINLEY, K. S. 2004b. Oil and water? High performance garbage collection in Java with JMTk. In Submitted for Publica- tion to ICSE (2004). http://www.cs.utexas.edu/users/mckinley/papers/jmtk-icse- submit-2003.ps.gz. (pp. 13, 15)
  10. BLACKBURN, S. M., JONES, R., MCKINLEY, K. S., AND MOSS, J. E. B. 2002. Belt- way: Getting around garbage collection gridlock. In Proceedings of the ACM SIG- PLAN Conference on Programming Language Design and Implementation (PLDI) (Berlin, Germany, June 2002). ACM. (pp. 11, 13)
  11. Bibliography BLACKBURN, S. M. AND MCKINLEY, K. S. 2003. Ulterior Reference Counting: Fast Garbage Collection without a long wait (Oct. 2003). OOPSLA 2003. (pp. 11, 16)
  12. BOEHM, H.-J. AND WEISER, M. 1988. Garbage collection in an uncooperative en- vironment. Software Practice and Experience 18, 9, 807-820. (p. 11)
  13. CHENEY, C. J. 1970. A non-recursive list compacting algorithm. Communications of the ACM 13, 11 (Nov.), 677-678. (p. 9)
  14. CLINGER, W. D. AND HANSEN, L. T. 1997. Generational garbage collection and the radioactive decay model. In SIGPLAN Conference on Programming Language De- sign and Implementation (1997), pp. 97-108. (p. 11)
  15. CLINGER, W. D. AND HANSEN, L. T. 2002. An experimental study of renewal- older-first garbage collection. In Proceedings of the International Conference on Func- tional Programming (Oct. 2002). ACM. (pp. 11, 12)
  16. COLLINS, G. E. 1960. A method for overlapping and erasure of lists. Communica- tions of the ACM 3, 12 (Dec.), 655-657. (p. 8)
  17. DEUTSCH, L. P. AND BOBROW, D. G. 1976. An efficient incremental automatic garbage collector. Communications of the ACM 19, 7 (July), 522-526. (p. 9)
  18. DIJKSTRA, E. W., LAMPORT, L., MARTIN, A. J., SCHOLTEN, C. S., AND STEFFENS, E. F. M. 1978. On-the-fly garbage collection: An exercise in cooperation. Commu- nications of the ACM 21, 11 (Nov.), 965-975. (p. 7)
  19. FENICHEL, R. R. AND YOCHELSON, J. C. 1969. A lisp garbage collector for virtual memory systems. Communications of the ACM 12, 11 (Nov.), 611-612. (p. 9)
  20. FLACK, C., HOSKING, T., AND VITEK, J. 2003. Idioms in ovm. Technical Report CSD-TR-03-017, Department of Computer Sciences, Purdue University. (p. 17)
  21. GARRIDO, A. AND JOHNSON, R. 2003. Refactoring C with conditional compilation. In 18th IEEE International Conference on Automated Software Engineering (ASE 2003) (Montreal, Canada, Oct. 2003), pp. 323-326. IEEE. (p. 43)
  22. GILANI, F. 2003. Title unknown. Master's thesis, Australian National University. (pp. 68, 71)
  23. GOSLING, J., JOY, B., STEELE, G., AND BRACHA, G. 2000. The Java Language Speci- fication. Addison-Wesley. (p. 73)
  24. HANSEN, W. J. 1969. Compact list representation: Definition, garbage collection and system implementation. Communications of the ACM 12, 9 (Sept.), 499-507. (p. 9)
  25. HENDERSON, F. 2002. Accurate garbage collection in an uncooperative environ- ment. In Proceedings of the third international symposium on Memory management (2002), pp. 150-156. ACM Press. (p. 78)
  26. HUDSON, R., MOSS, E., DIWAN, A., AND WEIGHT, C. F. 1991. A language- independent garbage collector toolkit. Technical Report TR 91-47, University of Massachusetts at Amherst. (p. 13)
  27. JOHNSSON, T. 1984. Efficient compilation of lazy evaluation. In Proc. ACM SIG- PLAN '84 Symposium on Compiler Construction (1984). SIGPLAN Notices 19(6). (pp. 18, 47)
  28. JONES, R. AND LINS, R. 1996. Garbage Collection. John Wiley and Sons. (pp. 5, 8, 12) LEVANONI, Y. AND PETRANK, E. 2001. An on-the-fly reference counting garbage collector for java. In ACM Conference on Object-Oriented Programming, Systems, Lan- guages, and Applications (OOPSLA'01). (2001), pp. 367-380. (p. 9)
  29. LIEBERMAN, H. AND HEWITT, C. 1983. A real-time garbage collector based on the lifetimes of objects. Communications of the ACM 26, 6, 419-429. (p. 10)
  30. MCCARTHY, J. 1960. Recursive functions of symbolic expressions and their com- putation by machine. Communications of the ACM 3, 4 (April), 173-197. (pp. 7, 8)
  31. NELSON, G. Ed. 1991. Systems Programming with Modula-3. Prentice Hall. (p. 74)
  32. PARR, T. 2002. ANTLR: Another Tool for Language Recognition. http://www.antlr.org/. (p. 41)
  33. PARR, T. J. 1994. An overview of SORCERER: A simple tree-parser generator. Tech- nical report, http://www.antlr.org/. (p. 41)
  34. PARR, T. J. AND QUONG, R. W. 1995. Antlr: A Predicated-LL(k) Parser. Software- Practice And Experience 25, 7 (July), 789-810. (p. 41)
  35. PEYTON JONES, S. L. 1987. The implementation of Functional Programming Languages. Prentice Hall. (pp. 18, 47)
  36. PEYTON JONES, S. L. 1992. Implementing lazy functional languages on stock hard- ware: the spineless tagless g-machine. Journal of Functional Programming 2, 127-202. (p. 47)
  37. PEYTON JONES, S. L., MARLOW, S., AND REID, A. 1999. The STG runtime. http://www.haskell.org/ghc/. (p. 48)
  38. QUINANE, L. 2003. Honours thesis. A.N.U. (p. 9)
  39. RITCHIE, S. 1997. Systems Programming in Java. IEEE Micro 17, 3 (May/June), 30- 35. (pp. 16, 73)
  40. ROVNER, P. 1985. On adding garbage collection and runtime types to a strongly typed, statically-checked, concurrent language. Technical report CSL-84-7 (July), Xerox PARC, Palo Alto, CA. (p. 5)
  41. SANSOM, P. 1991. Dual-mode garbage collection. In H. GLASER AND P. H. HAR- TEL Eds., Proceedings of the Workshop on the Parallel Implementation of Functional Lan- guages (Southampton, UK, 1991), pp. 283-310. Department of Electronics and Com- puter Science, University of Southampton. (p. 12)
  42. STEFANOVI Ć, D. 1993. The garbage collection toolkit as an experimentation tool. OOPSLA 1993 Workshop on Memory Management and Garbage Collection. (p. 13) Bibliography
  43. STEFANOVIC, D., MCKINLEY, K. S., AND MOSS, J. E. B. 1999. Age-based garbage collection. In OOPSLA '99 (1999), pp. 370-381. (p. 11)
  44. STEFANOVI Ć, D., MOSS, J. E. B., AND MCKINLEY, K. S. 1998. Oldest-first garbage collection. Technical Report 98-81, University of Massachusetts. (p. 11)
  45. UNGAR, D. M. 1984. Generation scavenging: A non-disruptive high performance storage reclamation algorithm. ACM SIGPLAN Notices 19, 5 (April), 157-167. (p. 10)
  46. WADSWORTH, C. P. 1971. Semantics and Pragmatics of the lambda calculus. PhD the- sis, Oxford University. (p. 48)
  47. WARRINGTON, I. 2003. Honours thesis. A.N.U. (p. 9)
  48. WILSON, P. R. 1992. Uniprocessor garbage collection techniques. In H. BAKER Ed., Proceedings of the International Workshop on Memory Management, Volume 637 of Lec- ture Notes in Computer Science (St Malo, France, Sept. 1992). Springer-Verlag. (p. 86)
  49. WILSON, P. R. 1994. Uniprocessor garbage collection techniques. Expanded ver- sion of [Wilson 1992]. (p. 12)
  50. WILSON, P. R., JOHNSTONE, M. S., NEELY, M., AND BOLES, D. 1995. Dynamic storage allocation: A survey and critical review. In H. BAKER Ed., Proceedings of In- ternational WOrkshop on Memory Management, IWMM'95, Kinross, Scotland, Volume 986 of Lecture Notes in Computer Science (Sept. 1995). Springer-Verlag. (p. 6)
  51. ZORN, B. 1991. The effect of garbage collection on cache performance. Techni- cal Report CU-CS-528-91, Department of Computer Science, Boulder, Colorado. (p. 5)

Related papers

Porting the JMTk memory management toolkit
Robin Garner

Citeseer

View PDFchevron_right
A Language-Independent Garbage Collector Toolkit
Eliot Moss

1991

We describe a memory management toolkit for language implementors. It offers efficient and flexible generation scavenging garbage collection. In addition to providing a core of languageindependent algorithms and data structures, the toolkit includes auxiliary components that ease implementation of garbage collection for programming languages. We have detailed designs for Smalltalk and Modula-3 and are confident the toolkit can be used with a wide variety of languages. The toolkit approach is itself novel, and our design includes a number of additional innovations in flexibility, efficiency, accuracy, and cooperation between the compiler and the collector.

View PDFchevron_right
On effectiveness of GC in Java
Darko Stefanovic

ACM SIGPLAN Notices, 2001

We study the effectiveness of garbage collection (GC) algorithms by measuring the time difference between the actual collection time of an object and the potential earliest collection time for that object. Our ultimate goal is to use this study in order to develop static analysis techniques that can be used together with GC to allow earlier reclamation of objects. The results may also be used to pinpoint application source code that could be rewritten in a way that would allow more timely GC. Specifically, we compare the objects reachable from the root set to the ones that are actually used again. The idea is that GC could reclaim unused objects even if they are reachable from the root set. Thus, our experiments indicate a kind of upper bound on storage savings that could be achieved. We also try to characterize these objects in order to understand the potential benefits of various static analysis algorithms. The Java Virtual Machine (JVM) was instrumented to measure objects that are reachable, but not used again, and to characterize these objects. Experimental results are shown for the SPECjvm98 benchmark suite. The potential memory savings for these benchmarks range from 23% to 74%.

View PDFchevron_right
Implementing an on-the-fly garbage collector for Java
Katherine Barabash

ACM SIGPLAN Notices, 2001

Java uses garbage collection (GC) for the automatic reclamation of computer memory no longer required by a running application. GC implementations for Java Virtual Machines (JVM) are typically designed for single processor machines, and do not necessarily perform well for a server program with many threads running on a multiprocessor. We designed and implemented an on-the-fly GC, based on the algorithm of Doligez, Leroy and Gonthier [13, 12] (DLG), for Java in this environment. An on-the-fly collector , a collector that does not stop the program threads, allows all processors to be utilized during collection and provides uniform response times. We extended and adapted DLG for Java (e.g., adding support for weak references) and for modern multiprocessors without sequential consistency, and added performance improvements (e.g., to keep track of the objects remaining to be traced). We compared the performance of our implementation with stop-the-world mark-sweep GC. Our measurements sho...

View PDFchevron_right
Memory Reclamation by Garbage Collectors: SPECjvm 2008
Nitan Singh

In earlier languages the memory management is done explicitly by the programmer himself. Now with the advent of modern object oriented languages like Java and C# the programmer is relived from explicitly managing the memory. A special program thread known as garbage collector takes care of managing the memory implicitly. The process of automatically reclaiming memory from dead objects (the objects that are not referenced from program or any other live object) is known as garbage Collection (GC). There are various metrics that affect the performance of the mutator. In the current research paper we have experimentally tested the four garbage collectors on various benchmarks of SPECjvm2008 and calculated how much memory is reclaimed after each (minor and major) collection.

View PDFchevron_right

Related topics

  • Memory Management
  • Garbage Collection
    • 580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved