Academia.eduAcademia.edu

Outline

Title
Abstract
Introduction
Schedulability Analysis
Empirical Evaluation Results
Related Work
Conclusion
References
All Topics
Computer Science
Software Engineering

Scheduling Hard Real-time Garbage Collection

Profile image of Tomas KaliberaTomas Kalibera

2009, Proceedings - Real-Time Systems Symposium

https://doi.org/10.1109/RTSS.2009.40
visibility

…

description

12 pages

link

1 file

Abstract

Managed languages such as Java and C# are increasingly being considered for hard real-time applications because of their productivity and software engineering advantages. Automatic memory management, or garbage collection, is a key enabler for robust, reusable libraries, yet remains a challenge for analysis and implementation of real-time execution environments. This paper comprehensively compares the two leading approaches to hard real-time garbage collection. While there are many design decisions involved in selecting a real-time garbage collection algorithm, for timebased garbage collectors researchers and practitioners remain undecided as to whether to choose periodic scheduling or slackbased scheduling. A significant impediment to valid experimental comparison is that the commercial implementations use completely different proprietary infrastructures. Here, we present Minuteman, a framework for experimenting with realtime collection algorithms in the context of a high-performance execution environment for real-time Java. We provide the first comparison of the two approaches, both experimentally using realistic workloads, and analytically in terms of schedulability.

Related papers

Hiearchical real-time garbage collection
Antony Hosking

2007

Memory management is a critical issue for correctness and perfor-mance in real-time embedded systems. Recent work on real-time garbage collectors has shown that it is possible to provide guar-antees on worst-case pause times and minimum mutator utiliza-tion time. This paper presents a new hierarchical real-time garbage collection algorithm for mixed-priority and mixed-criticality envi-ronments. With hierarchical garbage collection, real-time program-mers can partition the heap into a number of heaplets and for each partition choose to run a separate collector with a schedule that matches the allocation behavior and footprint of the real-time task using it. This approach lowers worst-case response times of real-time applications by 26%, while almost doubling mutator utiliza-tion – all with only minimal changes to the application code.

View PDFchevron_right
Eliminating Garbage Collec—tion for Embedded Real—time Software
Jameela Al-jaroodi

2005

One of the problems with Java for real-time and embedded real-time systems is the unpredictable behavior of garbage collection (GC). GC introduces unexpected load and causes undesirable delays for real-time applications. In this paper, we propose a technique that reduces and ...

View PDFchevron_right
Experimental Measurements of a Real-Time Garbage Collection Architecture
Kelvin Nilsen

1992

This report contains the raw empirical data on which the results of ISU DCS Technical Report 92{25 are based. Section 1 contains the input data for the programs that constituted the experimental workload, and section 2 lists the conguration data for the simulated architecture. Sections 3, 4, and 5 contain the results of individual experiments used in chapters 5, 6, and 7, respectively, of TR 92{25.

View PDFchevron_right
Hardware-Assisted General-Purpose Garbage Collection for Hard Real-Time Systems
Kelvin Nilsen

1992

Hardware-assisted garbage collection combines the potential of high average-case allocation rates and memory bandwidth with fast worst-case allocation, fetch, and store times. This paper describes an architecture that allows memory fetch and store operations to execute, on the av erage, nearly as fast as traditional memory. Support for caching garbage-collected memory cells and a protocol designed to minimize communication between the CPU’s cache and memory allow the system to deliver very high performance. The architecture is real-time in that the worst-case time required for a memory fetch or store is approximately six traditional memory cycles, and the time required to allocate an object is bounded by a small constant times the size of the object. A prototype of the proposed architecture has been successfully simulated. Continuing research focuses on measuring the system’s performance under real workloads.

View PDFchevron_right
Java Garbage Collection Scheduling in Utility Accrual Scheduling Environments
E. Douglas Jensen

Jtres, 2005

Convenience, reliability, and effectiveness of automatic memory management have long been established in modern systems and programming languages such as Java. The timeliness requirements of real-time systems, however, impose specific demands on the operational parameters of the garbage collector. The memory requirements of real-time tasks must be accommodated with a predictable impact on the timeline, and under the purview of the scheduler.

View PDFchevron_right
Real-time garbage collection
Eliot Moss

The Garbage Collection Handbook, 2011

View PDFchevron_right
Memory Management for Real-Time Java: An Efficient Solution using Hardware Support*
Valérie Issarny

Real-Time Systems, 2000

This paper addresses the issue of improving the performance of memory management for real-time Java applications, building upon the real-time speci®cation for Java (RTSJ) from the Real-Time Java Expert Group. In a ®rst step, a collecting dynamic memory solution including both a real-time garbage collector and region-based memory management, is proposed. A thorough analysis of the parameters in¯uencing the performance of write barriers in memory management, together with ways of improvement are then presented. Finally, the implementation of a memory management solution compliant with the RTSJ and integrating the proposed improvements is sketched.

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
Automatic Determination of Factors for Real-Time Garbage Collection
Tobias Mann

2004

Several approaches to hard, real-time garbage collection have been recently proposed. All of these approaches require knowing certain statistical properties about a program's execution, such as the maximum extent of live storage, the rate of storage allocation, and the number of non-null object references. While these new approaches o er the possibility of guaranteed, reasonably bounded behavior for garbage collection, the determination of the required information may not be straightforward for the application programmer.

View PDFchevron_right
Reliable General Purpose Dynamic Memory Management for Real-Time Systems
Kelvin Nilsen

Rtss, 1994

Traditional dynamic memory management techniques for imperative programming languages are unsuitable for reliable real-time applications because their worst-case time and space requirements are insufficiently bounded. This is demonstrated by detailed measurements of several real-world workloads. A special hardwareassisted real-time garbage collection system has been designed to facilitate reliable use of dynamic memory in hard real-time systems. By analyzing the dynamic memory use of application software, the real-time developer can prove compliance with time and space constraints. Analysis techniques are presented and the real-time performance of the hardware-assisted garbage collection system is compared to that of traditional allocators. Disciplines

View PDFchevron_right

References (30)

  1. G. Bollella, J. Gosling, B. Brosgol, P. Dibble, S. Furr, and M. Turnbull, The Real-Time Specification for Java. Addison- Wesley, 2000.
  2. A. Armbruster, J. Baker, A. Cunei, D. Holmes, C. Flack, F. Pizlo, E. Pla, M. Prochazka, and J. Vitek, "A Real- time Java virtual machine with applications in avionics," ACM Transactions in Embedded Computing Systems (TECS), vol. 7, no. 1, 2007.
  3. F. Pizlo and J. Vitek, "Memory management for real-time Java: State of the art," in Proceedings of the IEEE Sym- posium on Object-oriented Real-Time Distributed Computing (ISORC), 2008.
  4. J. Honig Spring, F. Pizlo, R. Guerraoui, and J. Vitek, "Reflexes: Abstractions for highly responsive systems," in Proceedings of the ACM/USENIX Conference on Virtual Execution Environments (VEE), 2007.
  5. T. Kalibera, M. Prochazka, F. Pizlo, M. Decky, J. Vitek, and M. Zulianello, "Real-time Java in space: Potential benefits and open challenges," in Proceedings of Data Systems in Aerospace (DASIA), 2009.
  6. D. F. Bacon, P. Cheng, and V. T. Rajan, "A real-time garbage collector with low overhead and consistent utilization," in Proceedings of the ACM Symposium on Principles of Pro- gramming Languages (POPL), 2003.
  7. R. Henriksson, "Scheduling garbage collection in embedded systems," Ph.D. dissertation, Lund University, 1998.
  8. G. Bollella, B. Delsart, R. Guider, C. Lizzi, and F. Parain, "Mackinac: Making hotspot real-time," in Proceedings of the Eighth IEEE Symposium on Object-Oriented Real-Time Distributed Computing (ISORC), 2005.
  9. J. Auerbach, D. F. Bacon, P. Cheng, D. Grove, B. Biron, C. Gracie, B. McCloskey, A. Micic, and R. Sciampacone, "Tax-and-spend: democratic scheduling for real-time garbage collection," in Proceedings of the ACM Conference on Em- bedded Software (EMSOFT), 2008.
  10. R. A. Brooks, "Trading data space for reduced time and code space in real-time garbage collection on stock hardware," in Proceedings of the ACM Symposium on Lisp and Functional Programming (LFP), 1984.
  11. S. Nettles and J. O'Toole, "Real-time replication garbage collection," in Proceedings of the ACM Conference on Pro- gramming Language Design and Implementation (PLDI), 1993.
  12. T. Yuasa, "Real-time garbage collection on general-purpose machines," Journal of Systems and Software, vol. 11, no. 3, 1990.
  13. J. Baker, A. Cunei, F. Pizlo, and J. Vitek, "Accurate garbage collection in uncooperative environments," Concurrency and Computation: Practice and Experience, 2009.
  14. M. Joseph and P. K. Pandya, "Finding response times in a real-time system," Computer Journal, vol. 29, no. 5, 1986.
  15. C. J. Fidge, "Real-time schedulability tests for preemptive multitasking," Real-Time Systems, vol. 14, no. 1, 1998.
  16. S. Gestegard Robertz and R. Henriksson, "Time-triggered garbage collection: robust and adaptive real-time GC schedul- ing for embedded systems," in Proceedings of the Conference on Languages, Compilers, and Tools for Embedded Systems (LCTES), 2003.
  17. M. Schoeberl, "Real-time garbage collection for Java," in IEEE Symposium on Object-Oriented Real-Time Distributed Computing (ISORC), 2006.
  18. P. Cheng and G. E. Blelloch, "A parallel, real-time garbage collector," in Proceedings of the ACM Conference on Pro- gramming language design and implementation (PLDI), 2001.
  19. E. J. Bruno and G. Bollella, Real-Time Java Programming with Java RTS. Prentice Hall, 2009.
  20. T. Kalibera, J. Hagelberg, F. Pizlo, A. Plsek, B. Titzer, and J. Vitek, "CDx: A family of real-time Java benchmarks," in Workshop on Java Technologies for Real-time and Embedded Systems (JTRES), 2009.
  21. A. Burns, K. Tindell, and A. Wellings, "Effective analysis for engineering real-time fixed priority schedulers," IEEE Transactions on Software Engineering, vol. 21, no. 5, 1995.
  22. S. M. Blackburn, et al., "The DaCapo benchmarks: Java benchmarking development and analysis," in Proceedings of the ACM Conference on Object-Oriented Programing, Systems, Languages, and Applications (OOPSLA), 2006.
  23. H. G. Baker, "List processing in real time on a serial computer," Communications of the ACM, vol. 21, no. 4, Apr. 1978.
  24. W. J. Schmidt and K. D. Nilsen, "Performance of a hardware- assisted real-time garbage collector," in Proceedings of the Conference on Architectural Support for Programming Lan- guages and Operating Systems, 1994.
  25. M. van Assche, J. Goossens, and R. Devillers, "Joint garbage collection and hard real-time scheduling," Journal on Embed- ded Computing, vol. 2, no. 3-4, 2006.
  26. J. Strosnider, J. Lehoczky, and L. Sha, "The deferrable server algorithm for enhanced aperiodic responsiveness in hard real-time environments," IEEE Transactions on Computers, vol. 44, no. 1, 1995.
  27. T. Kim, N. Chang, and H. Shin, "Joint scheduling of garbage collector and hard real-time tasks for embedded applications," Journal of Systems and Software, vol. 58, no. 3, 2001.
  28. D. F. Bacon, P. Cheng, and V. T. Rajan, "Controlling frag- mentation and space consumption in the Metronome, a real- time garbage collector for Java," in Proceedings of the ACM Conference on Language, Compiler, and Tool Support for Embedded Systems (LCTES), 2003.
  29. F. Siebert, "Real-time garbage collection in multi-threaded systems on a single processor," in IEEE Real-Time Systems Symposium (RTSS), 1999.
  30. D. Frampton, D. F. Bacon, P. Cheng, and D. Grove, "Gen- erational real-time garbage collection," in Proceedings of the European Conference on Object-Oriented Programming (ECOOP), 2007.

Related papers

Scheduling Real-Time Garbage Collection on Uniprocessors
Tomas Kalibera

ACM Transactions on Computer Systems, 2011

Managed languages such as Java and C# are increasingly being considered for hard real-time applications because of their productivity and software engineering advantages. Automatic memory management, or garbage collection, is a key enabler for robust, reusable libraries, yet remains a challenge for analysis and implementation of real-time execution environments. This paper comprehensively compares leading approaches to hard real-time garbage collection. There are many design decisions involved in selecting a real-time garbage collection algorithm. For time-based garbage collectors on uni-processors one must choose whether to use periodic, slack-based or hybrid scheduling. A significant impediment to valid experimental comparison of such choices is that commercial implementations use completely different proprietary infrastructures. We present Minuteman, a framework for experimenting with real-time collection algorithms in the context of a high-performance execution environment for real-time Java. We provide the first comparison of the approaches, both experimentally using realistic workloads, and analytically in terms of schedulability. A preliminary version of this work was presented at the 30th IEEE Real-Time Systems Symposium. Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies show this notice on the first page or initial screen of a display along with the full citation. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, to republish, to post on servers, to redistribute to lists, or to use any component of this work in other works requires prior specific permission and/or a fee. Permissions may be requested from Publications A:2 T. Kalibera et al.

View PDFchevron_right
Static determination of allocation rates to support real-time garbage collection
Tobias Mann

ACM SIGPLAN Notices, 2005

While it is generally accepted that garbage-collected languages offer advantages over languages in which objects must be explicitly deallocated, real-time developers are leery of the adverse effects a garbage collector might have on real-time performance. Semiautomatic approaches based on regions have been proposed, but incorrect usage could cause unbounded storage leaks or program failure. Moreover, correct usage cannot be guaranteed at compile time. Recently, real-time garbage collectors have been developed that provide a guaranteed fraction of the CPU to the application, and the correct operation of those collectors has been proven, subject only to the specification of certain statistics related to the type and rate of objects allocated by the application. However, unless those statistics are provided or estimated appropriately, the collector may fail to collect dead storage at a rate sufficient to pace the application's need for storage. Overspecification of those statistics is safe but leaves the application with less than its possible share of the CPU, which may prevent the application from meeting its deadlines.

View PDFchevron_right
Towards Efficient and Deterministic Memory Management for Real-Time Java
Jameela Al-jaroodi

2008

One of the problems facing the use of Java for real-time environments with limited memory such as embedded systems is the unpredictability of running garbage collection. This introduces unexpected load on the system and causes undesirable delay for the real-time applications. In this ...

View PDFchevron_right
Real-Time Garbage Collection for a Multithreaded Java Microcontroller
U. Brinkschulte, Theo Ungerer

Real-Time Systems, 2000

Keywords: garbage collection, microcontroller, Java microprocessor, real-time, multithreading We envision the upcoming of microcontrollers and systems-on-a-chip that are based on multithreaded processor kernels due to the fast context switching ability of hardware multithreading. Moreover we envision an extensive market for Java-based applications in embedded real-time systems.

View PDFchevron_right
Hierarchical real-time garbage collection
Jan Vitek

2007

Memory management is a critical issue for correctness and performance in real-time embedded systems. Recent work on real-time garbage collectors has shown that it is possible to provide guarantees on worst-case pause times and minimum mutator utilization time. This paper presents a new hierarchical real-time garbage collection algorithm for mixed-priority and mixed-criticality environments. With hierarchical garbage collection, real-time programmers can partition the heap into a number of heaplets and for each partition choose to run a separate collector with a schedule that matches the allocation behavior and footprint of the real-time task using it. This approach lowers worst-case response times of realtime applications by 26%, while almost doubling mutator utilization -all with only minimal changes to the application code.

View PDFchevron_right

Related topics

  • Software Engineering
  • Memory Management
  • Real Time Systems
  • Garbage Collection
  • Random access memory

    • Cited by

    Scheduling Real-Time Garbage Collection on Uniprocessors
    Jan Vitek

    ACM Transactions on Computer Systems, 2011

    Managed languages such as Java and C# are increasingly being considered for hard real-time applications because of their productivity and software engineering advantages. Automatic memory management, or garbage collection, is a key enabler for robust, reusable libraries, yet remains a challenge for analysis and implementation of real-time execution environments. This paper comprehensively compares leading approaches to hard real-time garbage collection. There are many design decisions involved in selecting a real-time garbage collection algorithm. For time-based garbage collectors on uni-processors one must choose whether to use periodic, slack-based or hybrid scheduling. A significant impediment to valid experimental comparison of such choices is that commercial implementations use completely different proprietary infrastructures. We present Minuteman, a framework for experimenting with real-time collection algorithms in the context of a high-performance execution environment for real-time Java. We provide the first comparison of the approaches, both experimentally using realistic workloads, and analytically in terms of schedulability. A preliminary version of this work was presented at the 30th IEEE Real-Time Systems Symposium. Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies show this notice on the first page or initial screen of a display along with the full citation. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, to republish, to post on servers, to redistribute to lists, or to use any component of this work in other works requires prior specific permission and/or a fee. Permissions may be requested from Publications A:2 T. Kalibera et al.

    View PDFchevron_right
    580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved