Modern garbage collectors rely on read and write barriers imposed on heap accesses by the mutator, to keep track of references between different regions of the garbage collected heap, and to synchronize actions of the mutator with those of the collector. It has been a long-standing untested assumption that barriers impose significant overhead to garbage-collected applications. As a result, researchers have devoted effort to development of optimization approaches for elimination of unnecessary barriers, or proposed new algorithms for garbage collection that avoid the need for barriers while retaining the capability for independent collection of heap partitions. On the basis of the results presented here, we dispel the assumption that barrier overhead should be a primary motivator for such efforts. We present a

A multi-tasking virtual machine (MVM) executes multiple programs in isolation, within a single operating system process. The goal of a MVM is to improve startup time, overall system throughput, and performance, by effective reuse and sharing of system resources across programs (tasks). However, multitasking also mandates a memory management system capable of offering a guarantee of isolation with respect to garbage collection costs, accounting of memory usage, and timely reclamation of heap resources upon task termination. To this end, we investigate and evaluate, novel task-aware extensions to a state-of-the-art MVM garbage collector (GC). Our task-aware GC exploits the generational garbage collection hypothesis, in the context of multiple tasks, to provide performance isolation by maintaining task-private young generations. Task aware GC facilitates concurrent per-task allocation and promotion, and minimizes synchronization and scanning overhead. In addition, we efficiently track per-task heap usage to enable GC-free reclamation upon task termination. Moreover, we couple these techniques with a light-weight synchronization mechanism that enables pertask minor collection, concurrently with allocation by other tasks. We empirically evaluate the efficiency, scalability, and throughput that our task-aware GC system enables. Categories and Subject Descriptors D.3.4 [Programming Languages]: Processors—Memory management (garbage collection)

Real-time software is commonly written in low level languages such as C and assembler. Such software is often hard to test, maintain, and port to other platforms. To improve this situation, high level languages are introduced in the real-time domain. The Java programming language has many properties that are appealing to real-time system development, e.g. robustness and portability. However, it is difficult to estimate the worstcase execution time of Java code using current implementations. This is due to several properties of Java, e.g. dynamic binding of method calls and automatic memory management. This thesis discusses the problems of introducing automatic memory management in hard real-time environments and proposes a technique called RT-Reference Counting to solve the problems. This technique is being integrated in a native Java compiler called RT-Java, being implemented at the Programming Environments Laboratory (PELAB) at Linköping University. An automatic memory manager for hard real-time systems must be able to guarantee that memory is always available to the application and that all memory management operations are fast and execution time predictable. Software based automatic memory managers for real-time systems exist, but they have problems, e.g. always guaranteeing short deadlines and/or handling large objects. RT-Reference Counting aims at solving these problems. The technique is not yet fully developed, but results so far are promising.

Read and write barriers mediate access to the heap allowing the collector to control and monitor mutator actions. For this reason, barriers are a powerful tool in the design of any heap management algorithm, but the prevailing wisdom is that they impose significant costs. However, changes in hardware and workloads make these costs a moving target. Here, we measure the cost of a range of useful barriers on a range of modern hardware and workloads. We confirm some old results and overturn others. We evaluate the microarchitectural sensitivity of barrier performance and the differences among benchmark suites. We also consider barriers in context, focusing on their behavior when used in combination, and investigate a known pathology and evaluate solutions. Our results show that read and write barriers have average overheads as low as 5.4 % and 0.9 % respectively. We find that barrier overheads are more exposed on the workload provided by the modern DaCapo benchmarks than on old SPECjvm98 benchmarks. Moreover, there are differences in barrier behavior between in-order and out-oforder machines, and their respective memory subsystems, which indicate different barrier choices for different platforms. These changing costs mean that algorithm designers need to reconsider their design choices and the nature of their resulting algorithms in order to exploit the opportunities presented by modern hardware.