Run Java applications on the Microsoft Cobalt 100 processors

Signed-off-by: odidev <[email protected]>

Author: odidev

content/learning-paths/servers-and-cloud-computing/java-on-azure/1-create-instance.md

@@ -0,0 +1,50 @@
+---
+title: Create an Arm based cloud virtual machine using Microsoft Cobalt 100 CPU 
+weight: 3
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Introduction
+
+There are several ways to create an Arm-based Cobalt 100 virtual machine : the Microsoft Azure console, the Azure CLI tool, or using your choice of IaC (Infrastructure as Code). This guide will use the Azure console to create a virtual machine with Arm-based Cobalt 100 Processor. 
+
+This learning path focuses on the general-purpose virtual machine of the D series. Please read the guide on [Dpsv6 size series](https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/general-purpose/dpsv6-series) offered by Microsoft Azure.  
+
+If you have never used the Microsoft Cloud Platform before, please review the microsoft [guide to Create a Linux virtual machine in the Azure portal](https://learn.microsoft.com/en-us/azure/virtual-machines/linux/quick-create-portal?tabs=ubuntu). 
+
+#### Create an Arm-based Azure Virtual Machine 
+
+Creating a virtual machine based on Azure Cobalt 100 is no different from creating any other virtual machine in Azure. To create an Azure virtual machine, launch the Azure portal and navigate to "Virtual Machines".
+1. Select "Create", and click on "Virtual Machine" from the drop-down list.
+2. Inside the "Basic" tab, fill in the Instance details such as "Virtual machine name" and "Region".
+3. Choose the image for your virtual machine (for example, Ubuntu 24.04) and select “Arm64” as the VM architecture.
+4. In the “Size” field, click on “See all sizes” and select the D-Series v6 family of virtual machines. Select “D4ps_v6” from the list.
+
+![Java Screenshot](images/instance.png)
+
+5. Select "SSH public key" as an Authentication type. Azure will automatically generate an SSH key pair for you and allow you to store it for future use. It is a fast, simple, and secure way to connect to your virtual machine.
+6. Fill in the Administrator username for your VM.
+7. Select "Generate new key pair", and select "RSA SSH Format" as the SSH Key Type. RSA could offer better security with keys longer than 3072 bits. Give a Key pair name to your SSH key.
+8. In the "Inbound port rules", select HTTP (80) and SSH (22) as the inbound ports.
+
+![Java Screenshot](images/instance1.png)
+
+9. Click on the "Review + Create" tab and review the configuration for your virtual machine. It should look like the following:
+
+![Java Screenshot](images/instance2.png)
+
+10. Finally, when you are confident about your selection, click on the "Create" button, and click on the "Download Private key and Create Resources" button.
+
+![Java Screenshot](images/instance4.png)
+
+11. Your virtual machine should be ready and running within no time. You can SSH into the virtual machine using the private key, along with the Public IP details.
+
+![Java Screenshot](images/instance5.png)
+
+{{% notice Note %}}
+
+To learn more about Arm-based virtual machine in Azure, refer to “Getting Started with Microsoft Azure” in [Get started with Arm-based cloud instances](/learning-paths/servers-and-cloud-computing/csp/azure).
+
+{{% /notice %}}

content/learning-paths/servers-and-cloud-computing/java-on-azure/2-deploy-java.md

@@ -0,0 +1,72 @@
+---
+title: Install Java on Microsoft Azure Virtual Machine
+weight: 5
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+
+
+## Java Installation on Azure Linux 3.0
+Install Java on Azure Linux 3.0 by updating the system and installing `java-devel`, which includes both JRE and JDK. Verify the installation using `java -version` and `javac -version`, then set the `JAVA_HOME` environment variable for Arm-based systems.
+
+
+### Install Java
+
+This Azure Linux 3.0 image does not include Java, so you need to install it.  
+
+First update tdnf:
+
+```console
+tdnf update -y 
+``` 
+Then install java-devel:
+
+```console
+tdnf install -y java-devel  
+```
+ 
+Java-devel installs both the default JRE and JDK provided by Azure Linux 3.0.
+
+Check to ensure that the JRE is properly installed: 
+
+```console
+java -version 
+``` 
+
+You should see an output similar to: 
+
+```output
+openjdk version "11.0.27" 2025-04-15 LTS 
+OpenJDK Runtime Environment Microsoft-11371464 (build 11.0.27+6-LTS) 
+OpenJDK 64-Bit Server VM Microsoft-11371464 (build 11.0.27+6-LTS, mixed mode, 
+sharing) 
+```
+
+Check to ensure that the JDK is properly installed:
+
+```console
+javac -version 
+```
+You should see an output similar to:
+
+```output
+javac 11.0.27 
+```
+
+Set Java Environment Variable for Arm: 
+
+```console 
+export JAVA_HOME=/usr/lib/jvm/msopenjdk-11 
+export PATH=$JAVA_HOME/bin:$PATH 
+```
+ 
+{{% notice Note %}}
+Azure Linux 3.0 offers the default JDK version 11.0.27. It’s important to ensure that your version of OpenJDK for Arm is at least 11.0.9, or above. There is a large performance gap between OpenJDK-11.0.8 and OpenJDK 11.0.9. A patch added in 11.0.9 reduces false-sharing cache contention. 
+For more information, you can view this [Arm community blog](https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/java-performance-on-neoverse-n1). 
+
+The [Arm Ecosystem Dashboard](https://developer.arm.com/ecosystem-dashboard/) also recommends Java/OpenJDK version 11.0.9 as minimum recommended on the Arm platforms.
+{{% /notice %}}
+
+Java installation is complete. You can now proceed with the baseline testing.

content/learning-paths/servers-and-cloud-computing/java-on-azure/_index.md

@@ -0,0 +1,63 @@
+---
+title: Run Java applications on the Microsoft Azure Cobalt 100 processors 
+
+minutes_to_complete: 60   
+
+who_is_this_for: This Learning Path introduces Java deployment on Microsoft Azure Cobalt 100 (Arm-based) virtual machines. It is designed for developers migrating Java applications from x86_64 to Arm with minimal or no changes.
+
+learning_objectives: 
+    - Provision an Azure Arm64 virtual machine using Azure console, with Ubuntu as the base image.
+    - Learn how to create an Azure Linux 3.0 Docker container.
+    - Deploy a Java application inside an Azure Linux 3.0 Arm64-based Docker container and an Azure Linux 3.0 custom-image-based Azure virtual machine.
+    - Perform Java benchmarking inside the container as well as the custom virtual machine.
+
+prerequisites:
+    - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100 based instances (Dpsv6). 
+    - A machine with [Docker](/install-guides/docker/) installed.
+
+author: Jason Andrews
+
+### Tags
+skilllevels: Advanced
+subjects: Performance and Architecture
+cloud_service_providers: Microsoft Azure
+
+armips:
+    - Neoverse
+
+tools_software_languages:
+    - Java
+    - Docker
+
+operatingsystems:
+    - Linux
+
+further_reading:
+  - resource:
+      title: Azure Virtual Machines documentation
+      link: https://learn.microsoft.com/en-us/azure/virtual-machines/
+      type: documentation
+  - resource:
+      title: Azure Container Instances documentation
+      link: https://learn.microsoft.com/en-us/azure/container-instances/
+      type: documentation
+  - resource:
+      title: Docker overview
+      link: https://docs.docker.com/get-started/overview/
+      type: documentation
+  - resource:
+      title: Java on Azure
+      link: https://learn.microsoft.com/en-us/java/azure/
+      type: documentation
+  - resource:
+      title: JMH (Java Microbenchmark Harness) documentation
+      link: https://openjdk.org/projects/code-tools/jmh/
+      type: documentation
+
+
+### FIXED, DO NOT MODIFY
+# ================================================================================
+weight: 1                       # _index.md always has weight of 1 to order correctly
+layout: "learningpathall"       # All files under learning paths have this same wrapper
+learning_path_main_page: "yes"  # This should be surfaced when looking for related content. Only set for _index.md of learning path content.
+---

content/learning-paths/servers-and-cloud-computing/java-on-azure/_next-steps.md

@@ -0,0 +1,9 @@
+---
+# ================================================================================
+#       FIXED, DO NOT MODIFY THIS FILE
+# ================================================================================
+weight: 21                  # Set to always be larger than the content in this path to be at the end of the navigation.
+title: "Next Steps"         # Always the same, html page title.
+layout: "learningpathall"   # All files under learning paths have this same wrapper for Hugo processing.
+---
+

content/learning-paths/servers-and-cloud-computing/java-on-azure/background.md

@@ -0,0 +1,17 @@
+---
+title: "About Cobalt 100 Arm-based processor"
+
+weight: 2
+
+layout: "learningpathall"
+---
+
+## What is Cobalt 100 Arm-based processor? 
+
+Azure’s Cobalt 100 is built on Microsoft's first-generation, in-house Arm-based processor: the Cobalt 100. Designed entirely by Microsoft and based on Arm’s Neoverse N2 architecture, this 64-bit CPU delivers improved performance and energy efficiency across a broad spectrum of cloud-native, scale-out Linux workloads. These include web and application servers, data analytics, open-source databases, caching systems, and more. Running at 3.4 GHz, the Cobalt 100 processor allocates a dedicated physical core for each vCPU, ensuring consistent and predictable performance. 
+
+To learn more about Cobalt 100, refer to the blog [Announcing the preview of new Azure virtual machine based on the Azure Cobalt 100 processor](https://techcommunity.microsoft.com/blog/azurecompute/announcing-the-preview-of-new-azure-vms-based-on-the-azure-cobalt-100-processor/4146353).
+
+## Introduction to Azure Linux 3.0
+
+Azure Linux 3.0 is Microsoft's in-house, lightweight Linux distribution optimized for running cloud-native workloads on Azure. Designed with performance, security, and reliability in mind, it is fully supported by Microsoft and tailored for containers, microservices, and Kubernetes. With native support for Arm64 (AArch64) architecture, Azure Linux 3.0 enables efficient execution of workloads on energy-efficient Arm-based infrastructure, making it a powerful choice for scalable and cost-effective cloud deployments.

content/learning-paths/servers-and-cloud-computing/java-on-azure/baseline.md

@@ -0,0 +1,63 @@
+---
+title: Java Baseline Testing 
+weight: 6
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+
+### Deploy a Java application with Tomcat-like operation 
+Apache Tomcat is a Java-based web application server (technically, a Servlet container) that executes Java web applications. It's widely used to host Java servlets, JSP (JavaServer Pages), 
+and RESTful APIs written in Java. 
+
+The below Java class simulates the generation of a basic HTTP response and measures the time taken to construct it, mimicking a lightweight Tomcat-like operation. It measures how long it 
+takes to build the response string, helping evaluate raw Java execution efficiency before deploying heavier frameworks like Tomcat.
+
+Create a file named `HttpSingleRequestTest.java`, and add the below content to it:
+
+```java
+public class HttpSingleRequestTest {
+    public static void main(String[] args) {
+        long startTime = System.nanoTime();
+        String response = generateHttpResponse("Tomcat baseline test on Arm64");
+        long endTime = System.nanoTime();
+        double durationInMicros = (endTime - startTime) / 1_000.0;
+        System.out.println("Response Generated:\n" + response);
+        System.out.printf("Response generation took %.2f microseconds.%n", durationInMicros);
+    }
+    private static String generateHttpResponse(String body) {
+        return "HTTP/1.1 200 OK\r\n" +
+               "Content-Type: text/plain\r\n" +
+               "Content-Length: " + body.length() + "\r\n\r\n" +
+               body;
+    }
+}
+```
+Compile and Run Java program :
+
+```console
+javac HttpSingleRequestTest.java
+java -Xms128m -Xmx256m -XX:+UseG1GC HttpSingleRequestTest
+```
+
+- -Xms128m  sets the initial heap size for the Java Virtual Machine to 128 MB. 
+- -Xmx256m sets the maximum heap size for the JVM to 256 MB. 
+- -XX:+UseG1GC enables the G1 Garbage Collector (Garbage First GC), designed for low pause times and better performance in large heaps.
+
+You should see an output similar to:
+```output
+
+Response Generated:
+HTTP/1.1 200 OK
+Content-Type: text/plain
+Content-Length: 29
+
+Tomcat baseline test on Arm64
+Response generation took 22125.79 microseconds.
+```
+Output summary:
+
+- The program generated a fake HTTP 200 OK response with a custom message.
+- It then measured and printed the time taken to generate that response (22125.79 microseconds).
+- This serves as a basic baseline performance test of string formatting and memory handling on the JVM running on an Azure Arm64 instance.

content/learning-paths/servers-and-cloud-computing/java-on-azure/benchmarking.md

@@ -0,0 +1,100 @@
+---
+title: Benchmarking via JMH
+weight: 7
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+Now that you’ve built and run the Tomcat-like response, you can use it to test the JVM performance using JMH. You can also use it to test the performance difference between Cobalt 100 instances and other similar D series x86_64 based instances.
+As noted before, the steps to benchmark remain the same, whether it's a Docker container or a custom virtual machine.
+
+## Run the performance tests using JMH
+
+JMH (Java Microbenchmark Harness) is a Java benchmarking framework developed by the JVM team at Oracle to measure the performance of small code snippets with high precision. It accounts for JVM optimizations like JIT and warm-up to ensure accurate and reproducible results. It measures the throughput, average latency, or execution time. Below steps help benchmark the Tomcat-like operation:
+
+
+Install Maven:
+
+```console
+tdnf install maven -y
+```
+Create Benchmark Project:
+
+```console
+mvn archetype:generate \
+  -DinteractiveMode=false \
+  -DarchetypeGroupId=org.openjdk.jmh \
+  -DarchetypeArtifactId=jmh-java-benchmark-archetype \
+  -DarchetypeVersion=1.37 \
+  -DgroupId=com.example \
+  -DartifactId=jmh-benchmark \
+  -Dversion=1.0
+cd jmh-benchmark
+```
+
+Edit the `src/main/java/com/example/MyBenchmark.java` file and add the below code on it:
+
+```java
+package com.example;
+import org.openjdk.jmh.annotations.Benchmark;
+public class MyBenchmark {
+
+    @Benchmarkpublic void benchmarkHttpResponse() {
+        String body = "Benchmarking a Tomcat-like operation";
+        StringBuilder sb = new StringBuilder();
+        sb.append("HTTP/1.1 200 OK\r\n");
+        sb.append("Content-Type: text/plain\r\n");
+        sb.append("Content-Length: ").append(body.length()).append("\r\n\r\n");
+        sb.append(body);
+        if (sb.length() == 0) throw new RuntimeException(); // avoid DCE    }
+}
+```
+This simulates HTTP response generation similar to Tomcat.
+
+Build the Benchmark:
+
+```console
+mvn clean install
+```
+
+After the build is complete, the JMH benchmark jar will be in the target/ directory.
+
+Run the Benchmark:
+
+```console
+java -jar target/benchmarks.jar
+```
+
+### Benchmark summary on x86_64:
+
+The following benchmark results are collected on two different x86_64 environments: a **Docker container running Azure Linux 3.0 hosted on a D4s_v6 Ubuntu-based Azure virtual machine**, and a **D4s_v4 Azure virtual machine created from the Azure Linux 3.0 image published by Ntegral Inc**.
+
+| Metric     | Value on Docker Container |  Value on Virtual Machine
+|----------------------------------|----------------------------------------|-------------------|
+| **Java Version**               | OpenJDK 11.0.27                        |    OpenJDK 11.0.27  |
+| **Run Count**                  | 25 iterations                         |     25 iterations   |
+| **Average Throughput**         | 21.88M ops/sec   |   15.39M ops/sec |
+| **Standard Deviation**         | ±0.0769M ops/sec                  |   ±0.17M ops/sec  |
+| **Confidence Interval (99.9%)**| [21.82M, 21.94M] ops/sec              |   [14.97M, 15.58M] ops/sec
+
+
+### Benchmark summary on Arm64:
+
+The following benchmark results are collected on two different Arm64 environments: a **Docker container running Azure Linux 3.0 hosted on a D4ps_v6 Ubuntu-based Azure virtual machine**, and a **D4ps_v6 Azure virtual machine created from the Azure Linux 3.0 custom image using the AArch64 ISO**.
+
+
+| Metric     | Value on Docker Container |  Value on Virtual Machine
+|----------------------------------|----------------------------------------|-------------------|
+| **Java Version**               | OpenJDK 11.0.27                        |    OpenJDK 11.0.27  |
+| **Run Count**                  | 25 iterations                         |     25 iterations   |
+| **Average Throughput**         | 35.60M ops/sec                    |   35.48M ops/sec |
+| **Standard Deviation**         | ±0.1618M ops/sec                   |   ±0.1918M ops/sec  |
+| **Confidence Interval (99.9%)**| [35.48M, 35.72M] ops/sec               |   [35.347M, 35.62M] ops/sec
+
+
+### **Highlights from Azure Linux Arm64 Benchmarking (JDK 11.0.27)**
+
+- **Superior Throughput:** Achieved an average of 35.60M ops/sec on Docker and 35.48M ops/sec on the virtual machine.
+- **Stable Performance:** Standard deviation on Docker is ±161,819.485 ops/sec and on the virtual machine is ±191,757.658 ops/sec, indicating consistent benchmarking results.
+- **Efficient Execution and Container Feasibility:** Demonstrates the efficiency of the Arm64 architecture for handling high-throughput Java workloads, even within a containerized Azure Linux environment.