Reliable Real-Time Garbage Collection of C++

Garbage collection of C++ offers the potential of improving prograrnmer productivity, reducing the occurrence of dynamic memory management errors in both prototype and production software, and increasing the level of abstraction provided by many reusable software components. The hardware-assisted real-time garbage collection system described in this paper offers the additional benefits of providing more predictable memory utilization and response times than are available from traditional dynamic memory management techniques for C++. This paper describes a C++ dialect that allows real-time garbage collection of heap-allocated objects in a manner that is compatible with traditional real-time development methodologies. This paper also provides a brief overview of established methodologies for development of reliable real-time software, with emphasis on issues that are relevant to garbage collection, and summarizes the shortcomings of existing real-time garbage collection techniques. @ 1994 The USENIX Association, Computing Systems, Vol. 7 . No. 4 . Fall L994 467

[1]  Dirk Grunwald,et al.  Evaluating models of memory allocation , 1994, TOMC.

[2]  Jay K. Strosnider,et al.  Dynamic versus Fixed Priority Scheduling: A Case Study , 1993 .

[3]  K. B. Kenny,et al.  A measurement-based performance analyzer for real-time programs , 1991, [1991 Proceedings] Tenth Annual International Phoenix Conference on Computers and Communications.

[4]  Frank W. Miller.  The performance of a mixed priority real-time scheduling algorithm , 1992, OPSR.

[5]  Sheng Cheng,et al.  Scheduling algorithms for hard real-time systems: a brief survey , 1989 .

[6]  Samuel N. Kamin.  Programming languages - an interpreter-based approach , 1990 .

[7]  W. Tindell.  AN EXTENDIBLE APPROACH FOR ANALYSING FIXED PRIORITY HARD REAL-TIME TASKS , 1994 .

[8]  Kelvin D. Nilsen,et al.  Garbage collection of strings and linked data structures in real time , 1988, Softw. Pract. Exp..

[9]  Scott Shenker,et al.  Mostly parallel garbage collection , 1991, PLDI '91.

[10]  Krithi Ramamritham,et al.  Scheduling Tasks with Resource Requirements in Hard Real-Time Systems , 1987, IEEE Transactions on Software Engineering.

[11]  James W. Layland,et al.  Scheduling Algorithms for Multiprogramming in a Hard-Real-Time Environment , 1989, JACM.

[12]  Kwei-Jay Lin,et al.  Building flexible real-time systems using the Flex language , 1991, Computer.

[13]  Alan C. Shaw,et al.  Reasoning About Time in Higher-Level Language Software , 1989, IEEE Trans. Software Eng..

[14]  David M. Ungar,et al.  Generation Scavenging: A non-disruptive high performance storage reclamation algorithm , 1984, SDE 1.

[15]  D. Parnas,et al.  On satisfying timing constraints in hard-real-time systems , 1991, SIGSOFT '91.

[16]  Skef Wholey,et al.  The design of an instruction set for common LISP , 1984, LFP '84.

[17]  Douglas Niehaus.  Program representation and translation for predictable real-time systems , 1991, [1991] Proceedings Twelfth Real-Time Systems Symposium.

[18]  Brian N. Bershad,et al.  The interaction of architecture and operating system design , 1991, ASPLOS IV.

[19]  Taiichi Yuasa,et al.  Real-time garbage collection on general-purpose machines , 1990, J. Syst. Softw..

[20]  William J. Schmidt,et al.  Issues in the design and implementation of a real-time garbage collection architecture , 1992 .

[21]  Rodney A. Brooks,et al.  Trading data space for reduced time and code space in real-time garbage collection on stock hardware , 1984, LFP '84.

[22]  Scott Nettles,et al.  Replication-Based Incremental Copying Collection , 1992, IWMM.

[23]  Scott Nettles,et al.  Real-time replication garbage collection , 1993, PLDI '93.

[24]  Benjamin G. Zorn,et al.  The measured cost of conservative garbage collection , 1993, Softw. Pract. Exp..

[25]  Richard Gerber,et al.  Compiling real-time programs into schedulable code , 1993, PLDI '93.

[26]  Kelvin D. Nilsen,et al.  Hardware-Assisted General-Purpose Garbage Collection for Hard Real-Time Systems , 1992 .

[27]  Ralph E. Johnson.  Reducing the latency of a real-time garbage collector , 1992, LOPL.

[28]  Lui Sha,et al.  On Countering the Effects of Cycle-Stealing in a Hard Real-Time Environment , 1987, RTSS.

[29]  S. L. Graham,et al.  List Processing in Real Time on a Serial Computer , 1978 .

[30]  Chung Laung Liu,et al.  Scheduling Algorithms for Multiprogramming in a Hard-Real-Time Environment , 1989, JACM.

[31]  John P. Lehoczky,et al.  Fixed priority scheduling of periodic task sets with arbitrary deadlines , 1990, [1990] Proceedings 11th Real-Time Systems Symposium.

[32]  Hans-Juergen Boehm,et al.  Garbage collection in an uncooperative environment , 1988, Softw. Pract. Exp..

[33]  David Lorge Parnas,et al.  Scheduling Processes with Release Times, Deadlines, Precedence, and Exclusion Relations , 1990, IEEE Trans. Software Eng..

[34]  Calton Pu,et al.  Fine-Grain Adaptive Scheduling using Feedback , 1989, Comput. Syst..

[35]  Dirk Grunwald,et al.  Empirical measurements of six allocation-intensive C programs , 1992, SIGP.

[36]  David Lorge Parnas,et al.  On Satisfying Timing Constraints in Hard-Real-Time Systems , 1993, IEEE Trans. Software Eng..

[37]  Tei-Wei Kuo,et al.  SSP: A semantics-based protocol for real-time data access , 1993, 1993 Proceedings Real-Time Systems Symposium.

[38]  Kelvin D. Nilsen,et al.  Cache Issues in Real-Time Systems , 1994 .

[39]  Aloysius K. Mok,et al.  Evaluating tight execution time bounds of programs by annotations , 1989 .

[40]  Wei-Kuan Shih,et al.  Algorithms for scheduling imprecise computations , 1991, Computer.

[41]  Hironori Kasahara,et al.  Parallel processing of robot-arm control computation on a multimicroprocessor system , 1985, IEEE J. Robotics Autom..

[42]  John R. Ellis,et al.  Safe, Efficient Garbage Collection for C++ , 1994, C++ Conference.

[43]  Kelvin D. Nilsen,et al.  Portable Execution Time Analysis for RISC Processors , 1994 .

[44]  Calton Pu,et al.  The Synthesis Kernel , 1988, Comput. Syst..