Projects

Massive Multicore
This research sub-project is an umbrella research stream to investigate larger .deep research. questions in the exploitation of heterogeneous multicore processors in accelerating the execution of the Java Virtual Machine. Within the sub-project larger research questions will be investigated and bleeding-edge research conducted by others outside of this project will be examined for applicability and integration into the other three Research & Development sub-projects.

Subproject: Massive Multicore Research
Project Lead: Dr. Kenneth B. Kent
The purpose of this research stream is to link in massive multicore research projects that are ongoing in the research community and within existing IBM research centers into the research happening at CAS-Atlantic in improving execution of the Java Virtual Machine (JVM) and Java Class Libraries (JCL). Some of these ongoing research projects include the development of primitives (data structures and templates) for efficient synchronization that provide building blocks for concurrency. TuningFork is a system for the visualization, analysis, and control of real-time systems. New trace formats, analysis modules, and visualizations can all be added as plug-ins. Marusa is a tool for breaking down the memory footprint of a Java application. This can be extremely useful for examining suites of applications to find patterns and commonalities that can be exploited to improve overall JVM memory management.

Virtual Machine (VM) Core
Research and development in the Virtual Machine (VM) core stream is centered around leveraging parallelism in the VM itself. This includes adding support for additional languages and APIs that can utilize multi-core architectures. Some of the sub-projects in this domain will investigate loading Java class libraries in parallel, enhancing the interface for applications to specify parallelism, and sharing Java VM support between applications.

Subproject: Leveraging Concurrency in the JVM
Project Lead: Dr. Eric Aubanel, Dr. Weichang Du
With the current trend towards scaling to larger numbers of hardware threads per CPU and machines with a larger number of CPUs (scaling out) as opposed to increasing the clock rate for a single CPU (scaling up), being able to leverage concurrency in the JVM is becoming more and more important. There are many aspects that need to be addressed, including:

• Optimizing the concurrency services (threading, synchronization, etc.) provided by the JVM through the Java APIs so that applications can take full advantage of the concurrency available.
• Optimizing the internal JVM implementation so that it takes full advantage of the available resources.
• Implementing new concurrency APIs that allow the efficient use of the available resources.
• Finding ways to allow the JVM to make existing application code take more advantage of the resources available without having to modify that code.

The goal of the research effort is to develop new JVM concurrency techniques and optimizations and to validate them by applying them to improve the concurrency services provided by the J9 JVM and to increase the level of concurrency within the JVM itself.

Subproject: Parallel Class Loading
Project Lead: Dr. Eric Aubanel, Dr. Kenneth B. Kent
The Java programming language was designed to be portable, robust, secure, and extensible and to support mobility of code. The Java virtual machine (JVM) and ClassLoader hierarchy provided by the base class library cooperate to realize these goals. The JVM is responsible for loading Java programs encoded as platform-neutral .class files as specified by the Java Virtual Machine Specification. The .class file format is designed for safety, and the Java language specification requires the JVM to do structural and semantic validation of the code during the loading process.

Java Class Libraries (JCL)
The Java Class Libraries (JCL) form the basic building blocks that users rely upon to build their applications. With the careful design and use of parallelism in these class libraries, user applications can realize an instant benefit from multicore architectures without spending additional specification time in their application development. As well, with tool support that can identify parallel opportunities in their user specifications, developers can be exposed and learn how to improve their applications for exploiting available parallelism if desired. This sub-project will address these issues in trying to increase performance by focusing on the end-user applications and how to best utilize multicore support.

Garbage Collection
With any addition of parallelism, the dependency on efficient memory management increases to avoid memory bottlenecks that limit performance. This research stream will research and develop support for efficient Garbage Collection (GC) within the Java VM. This is a difficult problem with much research needed to uncover how best to increase performance without affecting the responsiveness of the Java VM to user applications. With memory management acting as a background process, one must be careful to not interfere with user applications at undesirable times.