Delvin Defoe

Upper bound for defragmenting buddy heaps

Knuths buddy system is an attractive algorithm for managing storage allocation, and it can be made to operate in real-time. At some point, storage-management systems must either over-provide storage or else confront the issue of defragmentation. Because storage conservation is important to embedded systems, we investigate the issue of defragmentation for heaps that are managed by the buddy system. In this paper, we present tight bounds for the amount of storage necessary to avoid defragmentation. These bounds turn out to be too high for embedded systems, so defragmentation becomes necessary.We then present an algorithm for defragmenting buddy heaps and present experiments from applying that algorithm to real and synthetic benchmarks. Our algorithm relocates less than twice the space relocated by an optimal algorithm to defragment the heap so as to respond to a single allocation request. Our experiments show our algorithm to be much more efficient than extant defragmentation algorithms.

Theoretical constraints on multidimensional retiming design techniques

Image signal processing depends on computation intensive programs, which include the repetition of sequences of operations coded as nested loops. An effective technique in increasing the computing performance of such applications is the design and use of Application Specific Integrated Circuits using loop transformation techniques, and in particular, multi-dimensional (MD) retiming. The MD-retiming method improves the instruction-level parallelism of uniform loops. While many have written about the multi-dimensional retiming technique, no results have been published on the possible limitations of its application. This paper presents an analysis of that technique and its constraints when applied to nested loops with known index bounds, such as those found in two and three dimensional image processing.

Work in progress: Evaluating the use of mobile game development in introductory CS courses

Computer games have been accepted as an engaging and motivating tool in the CS curriculum. However, designing and implementing a playable game is challenging and is best done in advanced courses. Games for mobile devices offer the advantage of being simpler and, thus, easier to program for lower-level students. By exposing these students to a wide range of advanced topics, we can demonstrate to them that CS can be much more than coding. Here, we discuss our evaluation of a set of learning modules for introductory CS courses that use mobile game development as a motivational learning context.

A Fully Concurrent Garbage Collector

Over the past two decades, the number of memory-managed programming languages has proliferated. Such languages use uniprocessormemorymanagement techniques to allocate and reclaim storage on behalf of programs. Multicores and other forms of multiprocessor systems have evolved to become common place. However, deployed memory management techniques largely have not taken advantage of the benefits ofmultiprocessor systems.We present a fully concurrent garbage collector that offers negligible synchronization cost and leverages the power, speed, and potential of multicores and other multiprocessor systems. This collector makes its best effort to avoid suspending application threads as many concurrent (and other on-the-fly) collectors do. Instead, it retrieves requisite data opportunistically from each thread to compute its view of the heap and perform garbage collection work. Our collector is an efficient, high performance garbage collector that yields features that are desirable for multiprocessor real-time systems.

Teaching garbage collection with open source virtual machine

Garbage collection is an integral and fundamental component of every modern memory-managed programming language platform such as Java and Microsoft .Net. Yet, few Computer Science and Information Technology programs offer students a course on garbage collection. High tech companies wish that their new employees knew something about garbage collection as this would help them with decisions concerning languages that are most appropriate for implementing software solutions on behalf of their clients. To address this limitation, we have created a junior level undergraduate garbage collection course that gives students practical experience in exploring, designing, and implementing garbage collection algorithms in the context of an open source virtual machine. We have taught this course twice and on both occasions students were pleased with their learning experience.

On the connection between functional programming languages and real-time Java scoped memory

Java has recently joined C and C++ as a relatively high-level language suitable for developing real-time applications. Javas garbage collection, while generally a useful feature, can be problematic for real-time applications if collection occurs with unpredictable frequency and latency. The Real-Time Specification for Java#8482; (RTSJ) incorporates a scoped-memory model, akin to regions, that is not subject to garbage collection. However, applications are subject to strict rules concerning how objects can reference each other in scoped memory. Unfortunately, almost all extant Java code, including Javas vast and useful runtime libraries, will not execute properly in scoped-memory areas without significant modification. In this paper, we show that programs written in a pure functional programming language can be executed in a provably safe manner using scoped memory in RTSJ. This new connection allows extant implementations of important abstract data types to migrate safely to RTSJ. We also explore the effect of RTSJs referencing rules on the asymptotic, real-time behavior of some abstract data types.

Exploration of Dynamic Memory

Since the advent of the Java programming language and the development of real-time garbage collection, Java has become an option for implementing real-time applications. The memory management choices provided by real-time garbage collection allow for real-time Java developers to spend more of their time implementing real-time solutions. Unfortunately, the real-time community is not convinced that real-time garbage collection works in managing memory for Java applications deployed in a real-time context. Consequently, the Real-Time for Java Expert Group formulated the Real-Time Specification for Java (RTSJ) standards to make Java a real-time programming language. In lieu of garbage collection, the RTSJ proposed a new memory model called scopes, and a new type of thread called NoHeapRealTimeThread (NHRT), which takes advantage of scopes. While scopes and NHRTs promise predictable allocation and deallocation behaviors, no asymptotic studies have been conducted to investigate the costs associated with these technologies. To understand the costs associated with using these technologies to manage memory, Type of Report: PhD Dissertation Department of Computer Science & Engineering Washington University in St. Louis Campus Box 1045 St. Louis, MO 63130 ph: (314) 935-6160 WASHINGTON UNIVERSITY Sever Institute School of Engineering and Applied Science Department of Computer Science and Engineering Dissertation Examination Committee: Ron K. Cytron, Chair Guy M. Genin Christopher D. Gill William D. Smart Aaron Stump EXPLORATION OF DYNAMIC MEMORY MANAGEMENT SYSTEMS by Delvin Curvin Defoe A dissertation presented to the Graduate School of Arts and Sciences of Washington University in partial fulfillment of the requirements for the degree of Doctor of Philosophy August 2007 Saint Louis, Missouri copyright by Delvin Curvin Defoe 2007

Heap Defragmentation in Bounded Time

Knuth’s buddy system is an attractive algorithm for managing storage allocation, and it can be made to operate in real time. However, the issue of defragmentation for heaps that are managed by the buddy system has not been studied. In this paper, we present strong bounds on the amount of storage necessary to avoid defragmentation. We then present an algorithm for defragmenting buddy heaps and present experiments from applying that algorithm to real and synthetic benchmarks. Our algorithm is within a factor of two of optimal in terms of the time required to defragment the heap so as to respond to a single allocation request. Our experiments show our algorithm to be much more efficient than extant defragmentation algorithms.