Will Java Run More Sustainably on Arm's Architecture?

Making IT Systems More Green

As the term 'sustainability' became more commonly used in boardrooms and corporate strategy meetings, companies began to publicize their efforts and achievements to shareholders and customers alike. Almost all companies use IT systems in their day-to-day operations – regardless of industry – so this is a natural area of focus when it comes to sustainability.

Such discussions about reducing the carbon footprint of IT systems are particularly relevant in technology and finance spaces, which do not directly emit carbon as part of their business activities. The Green Software Foundation, of which NTT DATA is a steering member, has published a methodology: Software Carbon Intensity (SCI). This is a set of criteria to evaluate the carbon footprint of IT systems, including their power consumption.

The power consumption of each device depends on the behavior of the software commanding it, but it would be a big step towards reducing carbon emissions if we could run this software is run on energy-efficient devices. This is why we've focused on Arm's low-power-consumption architecture.

Increasing Applications for Arm's Architecture

Arm's architecture has been widely adopted by smartphone and embedded device manufacturers because of the emphasis these industries place on power conservation. However, its usefulness has not ended here. Recently, we have seen increasing adoption of Arm's technology in high-performance computing (HPC) centres, such as RIKEN's supercomputer 'Fugaku', and virtual machine instances for public cloud computing.

Arm itself has taken steps to emphasize the high power-to-performance ratio of its server processors – even sharing the benchmark information for Java applications on its hardware. At NTT DATA, we have many customers using systems developed in Java, and if they are able to run these applications in a green, low-emissions manner at scale, this will significantly improve their sustainability initiatives. Therefore, we decided to verify the power-saving effects of Arm's processors on Java enterprise applications.

Saving Power with Arm Processors for Java Applications

Test parameters

Please see a summary of the parameters for this test below:

• Application: ATRS, a sample application of NTT Group's Java development framework Macchinetta, which imitates an airline ticket reservation web system.
• Hardware: one Arm server (a Hewlett-Packard Enterprise RL300 Arm server) and one Intel Architecture (IA) x86 server.
  • We aimed to compare both servers – given that they have almost equal performance in terms of their CPU integer computation throughput, measured by their SPECrate2017_int_base score.
• Software: Rocky Linux 8.7 and OpenJDK 19.0.2 were used to run Java.
• Time: The test ran for 15 minutes, with the first 5 minutes acting as a ramp-up period to increase the load.

Test results

The comparative performance of the Arm and IA (x86) servers is illustrated in the chart below:

ATRS was the only software application running on both servers, so we can safely consider the differing power consumption as a reflection of each server's power efficiency. When we compare the steady-state power consumption in the second half of the graph, the IA (x86) server consumed 380 watts (W), and the Arm server consumed 240 W. In that time, the Arm server consumed 37% (or 140 W) less power than the IA server.

Given that Java architecture compiles programs into a platform-independent intermediate language and executes them on a Java Virtual Machine (JVM), an application running on two different servers would be identical not just in source code – but also at the binary level. From this, we can see that changing the server architecture alone has a significant impact on power consumption.

The JVM provides various runtime options, and experienced Java developers and operators will likely already have their preferred tuning settings, such as configuring the garbage collection functionality. The test results above were obtained without setting any special options. We also tested combinations of options related to garbage collection but found no significant difference from the base test results. This suggests that, in this case, the JVM was already well-optimized for the target application.

In recent years, the OpenJDK community has actively worked to improve Arm support by keeping pace with new instruction sets. Better Arm optimization will likely remain a key theme in OpenJDK development going forward.

Conclusion

The concept of a "green application" often centers on power savings from more efficient software processing, like improved algorithms. However, since programs run on hardware, the efficiency of the underlying hardware architecture is also crucial for greener IT systems overall.

Our tests showed that the Arm server can reduce power consumption for Java applications.
However, other software and tools (including runtimes and compilers) still face Arm compatibility and optimization challenges. Different hardware architectures require tailored approaches, so it's important to evaluate potential performance issues before deploying applications on Arm.

Fortunately, open-source software support for Arm is continuously improving over time. Container images for Arm deployment are also increasingly available alongside standard IA images. So, Arm is likely to remain a major architecture both on-premises and in the cloud.

Read more