Aleksandar Micic

Tax-and-spend: democratic scheduling for real-time garbage collection

Real-time Garbage Collection (RTGC) has recently advanced to the point where it is being used in production for financial trading, military command-and-control, and telecommunications. However, among potential users of RTGC, there is enormous diversity in both application requirements and deployment environments. Previously described RTGCs tend to work well in a narrow band of possible environments, leading to fragile systems and limiting adoption of real-time garbage collection technology. This paper introduces a collector scheduling methodology called tax-and-spend and the collector design revisions needed to support it. Tax-and-spend provides a general mechanism which works well across a variety of application, machine, and operating system configurations. Tax-and-spend subsumes the predominant pre-existing RTGC scheduling techniques. It allows different policies to be applied in different contexts depending on the needs of the application. Virtual machines can co-exist compositionally on a single machine. We describe the implementation of our system, Metronome-TS, as an extension of the Metronome collector in IBMs Real-time J9 virtual machine product, and we evaluate it running on an 8-way SMP blade with a real-time Linux kernel. Compared to the state-of-the-art Metronome system on which it is based, implemented in the identical infrastructure, it achieves almost 3x shorter latencies, comparable utilization at a 2.5x shorter time window, and mean throughput improvements of 10-20%.

Using field access frequency to optimize layout of objects in the JVM

Increasing data locality is a good way to alleviate the gap between memory latency and processor speed. Structure layout optimization is one way to improve spatial locality and consequently improve runtime performance by rearranging fields inside objects. This paper examines modifying IBMs JVM with the ability to reorder fields inside Java objects from access frequency information (hotness) in the presence of storage optimization. In order to decrease the overhead resulting from larger objects, the new layouts for Java objects are very similar to their default layouts in terms of size. The results are promising and we were able to reduce cache misses by as much as 12%, resulting in about 20% in performance improvement.

Effects of false sharing and locality on object layout optimization for multi-threaded applications

One approach to decrease the gap between memory latency and processor speed is improving locality of data. Data layout optimization is a way to increase locality by reordering data elements in memory. Unfortunately, for multi-threaded applications, the issue is more complex due to the effects of false sharing. In this paper, the effect of locality and false sharing on multi-threaded applications is investigated. Therefore, fields are reordered inside Java objects in such a way that improves the locality of reference among them and also decreases the estimated probability of false sharing. Considering the role of the JVM in laying out Java objects fields, IBMs JVM is modified with the ability to reorganize fields based on the profiled information.

Improving the performance of JVM startup using the shared class cache

The Java Virtual Machine (JVM) is responsible for executing all Java programs, so performance improvements in the JVM, especially pertaining to the startup of an application, have wide-ranging impact. This paper presents a solution that reduces the bottleneck by analyzing and optimizing various data structures inside the JVM before a Java application starts executing. The shared class cache, which was added to IBMs J9 VM to share classes and other immutable data across multiple runs of a JVM, is expanded to include additional data. Runtime improvements of between 15% and 20% were achieved in standard benchmark programs.

Object layout optimization in the JVM based on affinity

Improving spatial locality has a great impact on improving cache performance by reducing the number of cache misses. Object model optimization is one way to improve the locality of references inside particular objects. This paper extends the object layout optimization study by focusing on the internal layout of Java objects in applications running on the Java Virtual Machine (JVM). In this research, the IBM JVM is modified to be able to organize fields inside Java objects based on their access frequency and access order. Our results show reductions in the number of cache misses in the 20% range and an almost 40% speed up in some benchmarks.