- RTSJ Scoped Memory Analysis
- Multiprocessor Concurrent Garbage Collection
- Garbage Collection Taxonomy
My research focuses on choosing appropriate memory management schemes for real-time applications written in programming languages like Java. Two major schemes have been presented in the literature: the use of real-time garbage collection and the use of memory models that do not involve garbage collection. One of my research directions includes analyzing the cost associated with memory models that do not involve garbage collection.
Since real-time garbage collection is presented as a viable option for managing memory for real-time application written in Java, another facet of my research concerns the optimization of novel approaches to garbage collection on multi-processor systems. Such collectors posses features that are suitable for real-time systems.
The real-time community is not fully convinced that real-time garbage collection works in managing memory for applications deployed in real-time environments. As such, the Real-Time for Java Expert Group (RTJEG) developed the Real-Time Specifications for Java (RTSJ) standards to make Java a real-time programming language. In exchange for garbage collection, the RTSJ standards proposed a new memory model that uses memory areas (scopes) and new types of threads, called RealTimeThread and NoHeapRealTimeThread (NHRT), which take advantage of scopes. Objects allocated in a scope are not collected individually; instead, the entire scope is collected en masse when its last executing thread exits that scope. Scopes and NHRTs promise predictable allocation and deallocation behaviors.
Research interests: My research interest, as it pertains to RTSJ, lies in answering the question "Is the RTSJ scoped memory model, when used with NoHeapRealTimeThreads, better than real-time garbage collection?" How do they compare? To this end I have provided a framework to compute the asymptotic time cost of using the RTSJ scoped memory model with NHRTs. I have also analyzed the space overhead associated with this memory management scheme. An interesting discovery from my research is the observation that for a set of standard data structure operations (stacks, queues, etc.), the RTSJ scoped memory model produces no better time complexity than other memory management schemes. Another notable result is that the space-time trade-off for the RTSJ scoped memory model is no better than the same for real-time garbage collection.
An alternative to using scoped memory to manage memory for real-time systems is to use real-time garbage collection (e.g. Metronome). Although multiprocessor concurrent garbage collection is not the same as real-time garbage collection, advancements in multiprocessor concurrent garbage collection have demonstrated the feasibility of building low latency multiprocessor real-time garbage collectors. A particular multiprocessor concurrent garbage collector that captivated my attention is the On-the-Fly Reference Counting Garbage Collector by Levanoni and Petrank - LPC. LPC offers short pause times, minimal reference counting overhead, and a low synchronization write barrier. LPC is also an on-the-fly collector that uses the notion of handshakes (synchronization points) during collection to minimize the duration of mutator interruption.
Research interests: Although LPC offers a great set of features that are relevant to real-time systems, there are several areas in which LPC can be improved. In particular, the pause times of LPC can be reduced, the frequency of mutator interruptions can be cut in half, and the garbage collection cost can be minimized. I have addressed these issues in my research by designing a multiprocessor concurrent reference-counting garbage collector (ILPC) that cuts LPC's number of handshakes in half. Each handshake with a mutator in ILPC takes constant time since it is only a handful of pointer manipulations. The result is an efficient garbage collector with low collection cost, very short pause times, and infrequent mutator interruptions.
In the sixties there were only three garbage collection techniques; however, since the eighties there has been an explosion of garbage collection techniques. This explosion has lead to a lack of uniformity in the language used to reason about garbage collection. My research addresses this problem by establishing a taxonomy for unifying garbage collection technologies.
Research interests: There are several garbage collection features that are important to application developers. In particular, developers are concerned that garbage collection does not cause their application to sacrifice throughput, suffer long pauses, and incur unnecessary overhead. I have formalized a list of features that are relevant to application developers and formally defined them using language that unifies their varying representation in the literature. I have also provided metrics for a subset of these features so they can be utilized to quantitatively analyze and compare existing garbage collectors. The result is a garbage collection taxonomy called GC-Tax. GC-Tax will serve as a useful tool to assist developers in determining the most appropriate collector for their applications.