Improving Data Organization in Managed Runtimes for Improved Performance

点击翻译按钮获取中文摘要

Many software applications today are specified in interpreted languages. Interpretation allows applications to more easily execute and migrate on various platforms through the use of managed runtime technologies. This abstraction from the physical host as led to automation of resource acquisition and management such as processor scaling and memory management (garbage collection). As heap sizes increase, so does the cost incurred by garbage collection (GC) in managed runtimes. While scaling of dynamic memory in the host continues, so too does the demand by applications for more memory to satisfy the ever-increasing data to be processed. This discovery grant application is focused on the organization of data stored in dynamic memory within managed runtimes to achieve two goals. First, to segregate data objects/structures into different classes reflecting their access frequency to permit better mapping to different memory levels within the managed runtime. Second, to organize data within the dynamic memory so as to reduce pause times for garbage collection. Java programmers expect the Java Virtual Machine (JVM) to deal with all aspects of resource management, including the object heap, in a transparent way; the definition of the language, which has a create construct but no corresponding delete for objects, is emblematic of this. However, this illusion of infinite free space is destroyed on large GC pauses. Because of this, different approaches to GC need to be explored in order to achieve low, consistent pause times while keeping applications running smoothly and with high performance. To achieve this, I propose to explore new escape analysis techniques, and to investigate a segregated heap system for locally v. globally allocated objects. Cache and Translation Lookaside Buffer (TLB) misses cause large performance issues in most large Java applications. One way to mitigate these issues is by improving object locality. Improving object locality has proven to reduce cache and TLB misses in Java applications using the openJ9 JVM via Hierarchical Copying GC in the generational collector. When an object reference is followed from a parent object to a child the memory for the child object will need to be loaded into cache memory. If these objects were located within the same cache line or on the same memory page we could possibly save the cache and TLB misses. There several interesting areas of research that could improve object locality.