Browse Theses

Reviewer: Sergei Gorlatch

This work presents the design of SableVM, an extensible Java Virtual Machine (JVM). The goal of SableVM, as stated by the author, is to provide a portable, easily modifiable bytecode interpreter that can serve as a research platform for investigating new interpretation techniques, or new garbage collection mechanisms. After a brief introduction to bytecode interpretation in general, and to SableVM in particular, the next seven chapters each present an important aspect of the VM in more detail. Each chapter contains a section on related work, and presents experimental results to justify the used algorithms. The second chapter discusses different techniques to reduce the overhead of bytecode interpretation: switching, direct threading, and inline threading. The inline threading method is explained in more detail, and is adjusted to the special needs of Java bytecode interpretation. The next chapter discusses the memory layout of SableVM, and presents a partitioning of the runtime system memory: instead of allocating all memory from a garbage-collected heap, memory is allocated from different partitions according to its usage, for example, stack, class loader, and so on. Each partition has its own memory manager, implementing efficient strategies of memory management that are tailored for the specific usage type expected for that particular partition. Chapter 4 presents sparse interface virtual tables for method invocation, which reduce the overhead for interface method lookup by assigning unique indices to methods. This leads to sparse method tables with large gaps, which would require compression to be memory efficient. However, in SableVM, the partition-specific memory management introduced in the previous section solves this problem very elegantly, by filling the gaps with class loader related memory. The two following chapters discuss two aspects of garbage collection: object layout and garbage collection maps. The proposed bidirectional object layout reduces the number of memory accesses required to trace an object, by grouping all reference fields consecutively. This is achieved by letting an instance grow toward lower addresses for nonreference fields, and toward higher addresses for references. Space-efficient garbage collection maps are computed using an algorithm that assumes verifiable bytecode and performs a simple analysis of the code to compute stack maps and split local variables into reference and nonreference versions. By reordering local variables in methods, a single local variable map per method is sufficient. The last design aspect, discussed in chapter 7, is the implementation of thin locks for Java's monitors. An improved version of Bacon's and Onodera's algorithms, which avoids object instance inflation by using thread-specific storage for contention-related data structures, is presented. After a chapter about the portability and extensibility of the SableVM, overall performance measurements are presented. The experimental results show very good performance, when compared to other interpreting JVMs, but also show that an interpretation-only VM cannot compete with just in time (JIT)-compiling VMs. The thesis concludes with future work and conclusions. In general, the thesis gives a very good overview of interpretation techniques for Java, and discusses many important issues in the design of JVMs, such as garbage collection and memory management. The work is quite interesting to read, both for researchers planning to use SableVM to experiment with new VM-related techniques, and for readers with a general interest in the field.