Improving locality with dynamic memory allocation

Dynamic memory allocators are a determining factor of an application's performanceand have the opportunity to improve a major performance bottleneck ontoday's computer hardware: data locality. To approach this problem, a memoryallocator must rst oer strategies that allow the locality problem to be addressed.However, while focusing on locality, an allocator must also not ignore the existing constraintsof allocation speed and fragmentation, which further complicate its design. Inorder for a locality improving technique to be successfully employed in today's largecode applications, its integration needs to be automatic, without user intervention.The alternative, manual integration, is not a tractable solution.In this dissertation we develop three novel memory allocators that explore dierentallocation strategies that enhance an application's locality. We conduct the rststudy that shows that allocation speed, fragmentation and locality improving goalsare antagonistic. We develop an automatic method that supplies allocation hintsfrom C++ STL containers to their allocators. This method allows applications tobenet from locality improving techniques at the cost of a simple re-compilation. Weconduct the rst study that quanties the eect of allocation hints on performance,and show that an allocator with high locality of reference can be as competitive asone using an application's spatial feedback.To further allow dynamic memory allocation to improve an application's performance,new and non-traditional strategies need be explored. We develop a generic software tool that allows users to examine unconventional strategies. The tool allowsusers not only to focus on allocation strategies rather than their implementation, butalso to compare and contrast various approaches

Applying priorities to memory allocation

In embedded systems, memory is a scarce resource and great attention must be given to memory management. A novel approach of applying priorities to memory allocation is presented and it is shown how this can be used to enhance the robustness of real-time applications. Focus is on systems with automatic memory management, but the ideas are also applicable to manually managed memory. In systems with automatic memory management, the proposed mechanisms canalsobeusedtoincreaseperformancebylimitingthe amount of garbage collection work. Furthermore, a way of introducing priorities for memory allocation in a Java system without making any changes to the syntax of the Java language is proposed. This has been implemented in an experimental Java virtual machine

Flexible automatic memory management for real-time and embedded systems

The advent of safe languages like Java on the real-time systems scene motivates further research on efficient strategies for non-intrusive garbage collection and especially GC scheduling. This thesis presents new approaches to flexible and robust memory management from an engineering perspective and is a step towards write once --- run anywhere with hard real-time performance. The traditional approach to incremental GC scheduling, to perform garbage collection work in proportion to the amount of allocated memory, has drawbacks and in order to remedy this, a scheduling strategy, time-triggered GC, based on assigning a deadline for when the GC must complete its current cycle is proposed. It is shown that this strategy can give real-time performance that is equal to, or better than, that of an allocation-triggered GC. It is also shown that by using a deadline-based scheduler, the GC scheduling and, consequently, the real-time performance, is independent of a complex and error-prone work metric. Time-triggered GC also allows a more high-level view on GC scheduling as the GC cycle level rather than on each individual increment is considered. This makes it possible to schedule GC as any other thread. It also makes the time-triggered strategy well suited for auto-tuning and it is shown how an adaptive GC scheduler can be implemented. A novel approach of applying priorities to memory allocation is introduced and it is shown how this can be used to enhance the robustness of real-time applications. The proposed mechanisms can also be used to increase performance of systems with automatic memory management by limiting the amount of garbage collection work. The ideas brought forward in this thesis have been implemented and validated in an experimental real-time Java environment

Automatic memory management for flexible real-time systems

In a flexible real-time system, the constraints in available CPU time and memory lead to resource management problems, which must be handled carefully in order to maximize quality of service while avoiding overload. Managing CPU time -- scheduling -- is well studied and dynamic scheduling is widely accepted in the real-time industry. In order to make safe high-level languages, like Java, practically feasible for use in hard real-time systems, memory management and particularly the dependencies between memory and CPU usage must be studied. The traditional approach to incremental GC scheduling, to perform garbage collection work in proportion to the amount of allocated memory, has drawbacks such as inconsistent utilization due to bursty allocations. To remedy this, time-triggered GC scheduling is proposed. It is shown that this strategy gives real-time performance that is equal to, or better than, that of an allocation-triggered GC. It is also shown that by using a deadline-based scheduler, the GC scheduling and, consequently, the real-time performance, is independent of complex and error-prone work metrics. Time-triggered GC also allows a more high-level view on GC scheduling, as the entire GC cycle is considered rather than each individual increment. This makes it possible to schedule GC as a normal task. As the scheduling parameters are explicit in the model, it also makes the time-triggered strategy well suited for auto-tuning and fits well into feedback scheduling systems. A novel approach of applying priorities to memory allocation is introduced and it is shown how this can be used to enhance the robustness of real-time applications. The proposed mechanisms can also be used to increase performance of systems with automatic memory management by limiting the amount of garbage collection work. Together, these solutions facilitate flexible and robust automatic memory management for real-time systems. Adaptive techniques are presented, aimed at replacing or complementing a priori analysis with on-line auto-tuning. The presented ideas have been successfully implemented and validated in an experimental real-time Java environment, supporting the claim that this work is a step towards write once -- run anywhere with hard real-time performance