Application Runtimes

In the ever-evolving software development landscape, the synergy between cloud computing and programming languages like Java has revolutionized how applications are built, deployed, and scaled. At the heart of this transformation lies the concept of cloud compilers, a pivotal tool that seamlessly merges the power of Java with the scalability and accessibility of cloud infrastructure.

Introduction to Cloud Compilers

The idea behind a cloud compiler is to enable several Java clients to collectively access a compiler-as-a-service dynamically. This approach relieves each client from allocating extra CPU and memory resources for the demanding compilation task.

Cloud compilers represent a paradigm shift in traditional software development, offering Java developers many compelling advantages. As organizations increasingly embrace cloud-native architectures and agile methodologies, the role of cloud compilers becomes even more pronounced, facilitating rapid iteration, enhanced collaboration, and efficient resource utilization.

The Semeru Cloud Compiler is a specialized cloud compiler solution provided with Semeru Runtimes, IBM’s OpenJDK distribution of Java.

Semeru Runtimes

IBM Semeru Runtimes is an open-source Java runtime based on OpenJDK. It uses the class libraries from OpenJDK and leverages the Eclipse OpenJ9 Java Virtual Machine. This platform offers a dedicated environment for compiling, testing, and deploying Java applications directly from cloud infrastructure.

Key highlights

1. Stable and No-Cost Environment: IBM Semeru Runtimes provides a stable, no-cost environment for developing Java workloads. It can be used across various platforms, including on-premises, public and private cloud, and container orchestrators like Kubernetes and Red Hat OpenShift.

2. JDK Releases: Semeru Runtimes supports commonly used JDK releases such as JDK Long Term Support (LTS) releases 8, 11, 17, and 21.

3. Performance Benefits: Deep technology investment in the Eclipse OpenJ9 JVM provides excellent performance and low memory usage.

4. Zero Usage Restrictions: You can use Semeru Runtimes for development and production without restrictions.

5. Licensing Options: Semeru Runtimes come in two editions:

a. IBM Semeru Runtime Open Edition: Open-source license (GPLv2+Classpath extension).

b. IBM Semeru Runtime Certified Edition: IBM-licensed and Java TCK-certified.

Included with Semeru Runtimes and the OpenJ9 JVM is the Semeru Cloud Compiler, a cloud-based compiler that optimizes CPU and memory utilization and improves resiliency.

Semeru Cloud Complier

The Semeru Cloud Compiler is a feature that helps your Java applications run more efficiently. It does this by handling the task of turning your Java code into machine code (a process called “compiling”) separately from your application. This means that your application runs more efficiently because it no longer has to dedicate its own CPU and memory resources to the often intense overhead associated with compilation. It’s resilient — if something goes wrong with the compilation, your application can still keep running. This is especially helpful for applications running on Java runtimes like Liberty.

Key points

1. The Semeru Cloud Compiler provides just-in-time code compilation as a process independent of the application VM.

2. This decoupling provides CPU and memory utilization optimization in the application VM and improved resiliency.

3. If a failure occurs in the Semeru Cloud Compiler process, the application’s VM can still handle the compilation request.

4. It is designed to make it easier to develop and run Java applications more cost-effectively in hybrid cloud environments.

5. You can configure a containerized application to use the Semeru Cloud Compiler by using a Kubernetes custom operator.

6. The communication between the Semeru Cloud Compiler (server) and the application (client) can be encrypted.

How the Semeru Cloud Compiler works

The Semeru cloud compiler, also known as JITServer, is a feature of IBM Semeru Runtimes and the OpenJ9 JVM. It’s a technology that decouples the Just-in-Time (JIT) compiler from the Java Virtual Machine (JVM), allowing the JIT compiler to run remotely in its own process. This mechanism aids in preventing potential negative effects on your Java application due to CPU and memory consumption from JIT compilation.
The JITServer technology can improve the quality of service, robustness, and performance of Java applications. It’s particularly beneficial if your Java application needs to compile many methods by using JIT in a relatively short time or if the application is running in an environment with limited CPU or memory.

Java programs are transformed into architecture-neutral bytecodes by the javac compiler. When the program is running, the Java Virtual Machine (JVM) interprets these bytecodes. This method guarantees that Java programs can be run on various architectures, but it comes at the cost of performance due to the inherently slow nature of interpretation. To address this performance drawback, a Just-in-Time (JIT) compiler was introduced. The JIT compiler converts bytecode sequences into machine code during runtime, which is then stored in the JVM’s cache. This process significantly improves the execution speed of Java programs.

The workflow from Java code to execution on the host machine is as follows:

Compile time — Converting Java code to bytecode

• javac abc.java invokes the Java compiler that converts the Java code into bytecode (note that this is the standard Java compiler, not the JIT compiler that is run in the JVM).
• The bytecode is stored in a class file: abc.class

Runtime — Execute the bytecode on the host machine

• java abc loads the class file bytecode into the class loader of the JVM.
• The bytecode verifier ensures the security of the bytecode.
• One bytecode at a time, the interpreter converts the bytecode into machine code and executes it.
• The JIT compiler can improve execution performance 10x over the interpreter. Based on profiling metrics, the JIT compiler will supply machine code of recurring bytecodes to the JVM for execution.

The JITServer is not enabled by default; you must explicitly invoke it. You can launch Eclipse OpenJ9 in client mode, where the VM sends compilation requests to an available JITServer. If a server is not available, the client operates as a regular VM with its own JIT compiler. You can also start a JITServer process that listens for incoming compilation requests.

Advantages of distributed compilation

Distributed compilation in cloud compilers, such as Semeru, offers several advantages:

1. Workload Mitigation: Distributed compilation allows each phase of the compilation to be executed on a separate server. This distributes the workload across multiple servers, reducing the burden on any single system.
2. Scalability: Cloud-based compilers are designed to be scalable. They can handle several compilation requests per second, making them suitable for large-scale projects.
3. Efficiency: Compiled code tends to run faster than interpreted code because the translation into machine code allows the computer’s processor to execute it directly.
4. Portability: Compilers allow programmers to write code in a high-level programming language that can be easily translated into machine code for several platforms.
5. Increased Security: Compilers can help improve the security of the software by performing several checks on the source code, such as checking for syntax errors and enforcing type safety.
6. Debugging Support: Most compilers include several debugging tools that help programmers find and fix errors in their code.

In summary, distributed compilation in cloud compilers like Semeru provides a more efficient, scalable, and secure way of compiling code, making it an excellent choice for large-scale and complex projects.

Integration with WebSphere Liberty Operator

To configure the Semeru Cloud Compiler integration with the WebSphere Liberty Operator using a custom resource, follow these steps:

apiVersion: liberty.ibm.com/v1beta1
kind: WebSphereLibertyApplication
metadata:
name: my-app
spec:
semeruCloudCompiler:
enable: true
# Other application configuration fields…

Setting spec.semeruCloudCompiler.enable to true enables the Semeru Cloud Compiler for your WebSphere Liberty application. The operator handles the integration details, ensuring that code compilation is as efficient as possible.

Conclusion

The Semeru Cloud Compiler is a powerful tool for optimizing the performance and efficiency of your cloud applications. With its ability to improve CPU and memory utilization and its improved resiliency, it’s a technology worth considering for your next cloud project.

So, are you ready to unleash the power of Semeru Cloud Compilers in your applications? The future of cloud computing is here, and it’s more efficient and resilient than ever.