Dynamic memory allocation has been a fundamental part of most computer systems since roughly 1960, and memory allocation is widely considered to be either a solved problem or an insoluble one. In this survey, we describe a variety of memory allocator designs and point out issues relevant to their design and evaluation. We then chronologically survey most of the literature on allocators between 1961 and 1995. (Scores of papers are discussed, in varying detail, and over 150 references are given.) We argue that allocator designs have been unduly restricted by an emphasis on mechanism, rather than policy, while the latter is more important; higher-level strategic issues are still more important, but have not been given much attention. Most theoretical analyses and empirical allocator evaluations to date have relied on very strong assumptions of randomness and independence, but real program behavior exhibits important regularities that must be exploited if allocators are to perform well in practice.

We show that for 8 real and varied C and C++ programs, several conventional dynamic storage allocators provide nearzero fragmentation, once we account for overheads due to implementation details such as headers, alignment, etc. This substantially strengthens our previous results showing that the memory fragmentation problem has generally been misunderstood, and that good allocator policies can provide good memory usage for most programs. The new results indicate that for most programs, excellent allocator policies are readily available, and efficiency of implementation is the major challenge. While we believe that our experimental results are state-of-the-art and our methodology is superior to most previous work, more work should be done to identify and study unusual problematic program behaviors not represented in our sample. 1

Garbage collection is the automatic reclamation of computer storage [Knu73, Coh81, Wil92, Wil95]. While in many systems, programmers must explicitly reclaim heap memory at some point in their program by using a "free" or "dispose" statement, garbage collected systems free the programmer from this burden. In spite of its obvious attractiveness for many applications, garbage collection for real-time programs is not popular. This is largely due to the perceived cost and disruptiveness of garbage collection in general, and of incremental garbage collection in particular. Most existing "real-time" garbage collectors are not in fact usefully real-time, largely due to the use of a read barrier to trigger incremental copying of data structures being traversed by the running application. This may slow down running applications unpredictably, even though individual increments of garbage collection work are small and bounded. We have developed a hard real-time garbage collector which us...

Data intensive service functions such as memory allocation/de-allocation, data prefetching, and data relocation can pollute processor cache in conventional systems since the same CPU (using the same cache) executes both application code and system services. In this paper we show the improvements in cache performance that can result from the elimination of the cache pollution using separate caches for memory management functions. For the purpose of our study we simulate the existence of separate hardware units for the application and the memory management services using two Unix processes. One process executes application code (simulating main CPU) while the other executes memory management code. We collected address traces for the two processes and used Dinero IV cache simulator to evaluate the expected cache behaviors. A second goal of this paper is to examine the cache performance of different memory allocators. In this paper we compare two allocators: a very popular segregated list based allocator (originally due to Doug Lea) and our own binary-tree based allocator (called Address-ordered

Dynamic memory management is important and essential to the operation of a computer system. Efficient memory allocation, garbage collection and compaction are becoming increasingly critical in parallel, distributed and real-time applications using object-oriented languages like C++ and Java. In addition to achieving fast allocation/deallocation of memory objects, memory management techniques should strive to achieve low fragmentation and high storage utilization. Recently, we have proposed a memory management technique (Segregated Binary Tree) and reported data on its performance both in terms of storage utilization and execution speed. In this paper, we present how to exploit Intelligent Memory Devices to decouple the memory management from the central processing unit, and show how Segregated Binary Trees can be embedded in Intelligent Memory devices.

Dynamic memory management is an important and essential part of computer systems design. Efficient memory allocation, garbage collection and compaction are becoming increasingly more critical in parallel, distributed and real-time applications using object-oriented languages like C++ and Java. In this paper we present a technique that uses a Binary tree for the list of available memory blocks and show how this method can manage memory more efficiently and facilitate easy implementation of well known garbage collection techniques. Keywords: Dynamic Memory Management, Best Fit, First Fit, Buddy System, Memory Fragmentation, Garbage Collection, Generation Scavenging. 1. Introduction The need for more efficient memory management is currently being driven by the popularity of object-oriented languages in general ([Chang 99], [Calder 95]), and Java in particular [Abdullahi 98]. The trend towards the use of Java in Internet, real-time and embedded systems requires predictable and/or reason...

Dynamic memory management has been an active research area for the last four decades. The primary goals of any memory management technique are the speed of allocation & delloaction; and efficient storage utilization. In this paper, we introduce two new memory allocation techniques: Address Ordered Binary Trees (ABT) and Segregated Binary Trees (SBT). Our empirical results show how Address Ordered and Segregated Binary Trees can outperform other mechanisms with respect to storage utilization. In addition, the Segregated Binary Trees compare favorably with Segregated Free List approaches in terms of execution time.