User:AzulPM/Managed Runtime Initiative

The Managed Runtime Initiative is a software development and integration initiative launched by Azul Systems, Inc. on June 15th, 2010.

The goal of the Initiative is to improve the execution of managed runtimes (e.g. Java, Ruby, .Net) by enhancing interfaces and functionality across vertical components of the systems stack (e.g. managed runtime, OS kernel, Hypervisor and hardware layers). The initiative will encompass multiple projects, some of which are based on free and open source software.



A reference implementation of two projects was released in June 2010.

The first runtime project, the enhanced OpenJDK runtime project, included an enhanced version of OpenJDK 6. The enhanced OpenJDK runtime demonstrates how highly optimized modules can work in concert across enhanced interfaces in the system stack to achieve performance and scalability improvements.

The second runtime project, the enhanced Linux project, is a set of enhanced loadable Linux kernel objects (LKOs) that expose new functionality and interfaces, which are needed and used by the enhanced OpenJDK runtime project. LKOs provide new virtual memory subsystem, physical memory subsystem, and resource scheduler functionality and include capabilities which support garbage collection, high virtual memory allocation and manipulation rates, and policy enforcement. Changes are also provided to the Linux kernel to add hooks that enable the LKOs.

The long-term goal of the Managed Runtime Initiative is to provide a multi-project site, supporting both closed and open source projects, that promotes innovations and extensions across the layered interfaces in the systems stack. In addition, as new performances and scalability implementations are developed and matured, the Initiative’s goal is to upstream those related contributions into existing and complementary OSS projects (e.g. kernel.org, openjdk.org).

Build v1.0 for x86-64 platform is currently in development and is anticipated to be released in the second half of 2010.

History
The Managed Runtime Initiative was initially conceived as an effort to identify, develop, and deliver enhanced interfaces and functionality across vertical components of the systems stack (e.g. runtime, OS kernel, and hypervisor layers) to improve the execution of managed runtimes. Project goals included promoting innovations and extensions (through both closed and open source projects) across the layered interfaces in the systems stack, and when appropriate, to upstream those enhancements into existing and complementary OSS projects. Other companies and developers were invited to leverage a reference implementation for an enhanced OpenJDK runtime on an enhanced version of Linux, and to implement, use, and support APIs with similar functionality for other managed runtimes and operating systems. The initial release (version 0.9) was intended to demonstrate the scalability and performance benefits of the new interfaces and functionality in the systems stack, and supports only a limited set of Java applications. Subsequent releases are anticipated to augment these capabilities, improve robustness, and be fully compliant with the Java platform specification.

Improving Managed Runtime Execution
The Managed Runtime Initiative was started with the primary objective of improving the execution of managed runtimes on commonly used systems stacks (e.g. Linux on x86 servers).

Systems Stack Approach
Rather than focusing solely on improvements at the managed runtime layer, the Initiative’s aim is to identify, develop, advocate, and deliver new interfaces and functionality across various layers in the systems stack (e.g. the managed runtime, OS kernel, hypervisor, and hardware layers). These enhancements, working in concert, provide a more optimal managed runtime execution environment or platform.

Effecting Change in Systems Stack Implementations
In order to facilitate changes across multiple layers in the systems stack, represented by a wide array of projects and vendors, the Initiative focuses on advocating new interfaces and functionality, rather than specific APIs. It seeks to cooperate and coordinate with open source communities, closed source software vendors, as well as open systems platform vendors and standards bodies.

Demonstrating Value through Reference Implementations
Advocating for not-yet-available and not-yet-used interfaces would be challenging without being able to demonstrate clear, measureable value. The Managed Runtime Initiative aims to deliver coordinated reference implementations of interface and functionality across the systems stack, which can together demonstrate measurable value for managed runtime execution.
 * Note: While the process of identifying and developing new interfaces and functionality across multiple layers of the systems stack is expected to be ongoing, the initial scope and version of the enhanced OpenJDK runtime project (version 0.9) demonstrates orders of magnitude improvements in the execution of Java applications.

Interaction with Free and Open Source projects
Since free and open source software provides a great vehicle to demonstrate and advocate for new functionality and interfaces that would enhance managed runtime execution, it is expected that, in most cases, the Managed Runtime Initiative will produce working reference implementations based on common OSS software projects (e.g. Linux, OpenJDK, Ruby). To support and facilitate the goal of affecting common system stacks, such reference implementations may be contributed back and upstreamed into existing open source projects.

Progress and availability
The initial reference implementation for enhanced OpenJDK runtime (v0.9) on an enhanced version of Linux was released in June 2010. The components were tested to build and function correctly only against the specific versions of the tools and build environment as described in the documentation. The initial release of the enhanced OpenJDK runtime project was intended to demonstrate the scalability and performance benefits of the new interfaces and functionality in the system stack, and supports only a limited set of Java applications. Throughout 2010, it is anticipated that subsequent releases to the projects will provide a more complete, robust, and compliant solution.