Migration overview

Software developers are embracing the Arm architecture for its superior price performance and energy efficiency across a wide range of applications, including containerized workloads, cloud managed services, and Linux applications. To achieve higher performance and lower cost, you can migrate your self-managed workloads to Arm virtual machines and make sure to select Arm for managed services. A three step migration process covers the most common scenarios, and provides links to additional resources.

Image Alt Text: Arm migration overview

PREFACE: Learn and explore

Arm Neoverse is a family of processor cores designed for servers and cloud data centers. There are 2 families currently available, Neoverse V-series and Neoverse N-series.

What is Arm Neoverse?

Neoverse V-series offers the highest overall performance, and Neoverse N-series offers industry-leading performance-per-watt and serves a broad set of server and cloud use cases. Each Neoverse CPU implements a version of the Arm architecture . Arm continually works with partners to advance the architecture and increase computing capability. Neoverse cores focus on predictable per-socket performance and do not rely on multithreading or extreme clock speeds.

Below is a list of Neoverse CPUs, the architecture versions, and the key additions for each.

CPUArchitecture versionKey additions
Neoverse-N1Armv8.2-ALSE - Large System Extensions improves multi-threaded performance.
Neoverse-V1Armv8.4-ASVE - Scalable Vector Extension adds high performance vector processing for HPC and AI workloads.
Neoverse-N2Armv9.0-ASVE2 and Arm CCA - Extends SVE and adds Arm Confidential Compute Architecture for hardware isolation and security.
Neoverse-V2Armv9.0-ASVE2 and Arm CCA - Targets high single threaded performance for HPC and AI workloads.

What cloud hardware is available today?

Review each cloud service provider below to learn about Arm-based servers.

AWS offers more than 150 instance types with Graviton processors . The largest instance has 192 vCPUs and 1.5 TB of memory. A wide variety of instance sizes are available, including bare-metal (look for ‘.metal’). To find instances with Graviton processors look for ‘g’ in the name (C7g, M7g, and R7g).

GenerationArm CPUInstance typesComments
GravitonCortex-A72A1First Arm-based instance.
Graviton2Neoverse-N1C6g, M6g, R6g600% performance and efficiency increases.
Graviton3Neoverse-V1C7g, M7g, R7g25% performance increase, DDR5 memory added, 50% more memory bandwidth.
Graviton4Neoverse-V2R8g75% more memory bandwidth, up to 40% faster for databases and 30% faster for web applications.

Google GCP offers a varity of virtual machine instances with Arm processors . The largest instance has 80 vCPUs and 640 Gb of RAM in the ‘c3a-highmem’ format. It does not offer bare-metal instances. It offers compute for general-purpose workloads (standard) and memory-optimized workloads (highmem).

GenerationArm CPUInstance typesComments
T2ANeoverse-N1T2A-standardOptimized for general-purpose workloads - web servers, and microservices.
C3AAmpereOnec3a-standard, c3a-highmemCompute-optimized - large-scale databases, media transcoding, and HPC.

Microsoft Azure offers a variety of virtual machine instances with Arm Neoverse processors . The largest instance has 64 vCPUs and 208 Gb of RAM in the ‘D64ps_v5’ format. It does not offer bare-metal instances. It offers compute for general-purpose workloads (Dps), memory-optimized workloads (Eps), compute-intensive workloads (Fsv), and high-performance (Cobalt).

GenerationArm CPUInstance typesComments
psv5Neoverse-N1Dpsv5, Epsv5General purpose and memory optimized instances.
psv6Neoverse-N2Dpsv6, Epsv6, Fsv6Cobalt processor improves performance, Dpsv6 (general purpose 4:1 mem:cpu ratio), Dplsv6 (general purpose, 2:1 mem:cpu ratio), Epsv6 (memory-optimized).

Oracle Cloud Infrastructure (OCI) Ampere Arm-based compute provides market-leading price-performance for AI, containers, big data, web services, and related workloads. The largest intsance has 160 vCPUs and 1024 Gb of RAM in the ‘BM.Standard.A1’ format. It offers bare-metal instances (look for ‘BM’ as opposed to ‘VM’).

GenerationArm CPUInstance typesComments
A1Neoverse-N1VM.Standard.A1Offers predefined (.#CPUs) or dynamic OCPU and memory allocation (.Flex)
A2AmpereOneVM.Standard.A2, VM.Optimized3.A2Tailored for high-performance and memory-intensive workloads.

Read Get started with Servers and Cloud Computing to learn more and find additional cloud service providers.

STEP 1: Plan your transition

Newer software is generally easier to migrate because Arm support continues to improve and performance optimizations are typically better in newer versions. Interpreted languages and Jit compilers, such as Python, Java, PHP, and Node.js are easiest to migrate. Compiled languages such as C/C++, Go, and Rust are slightly more difficult because they need to be recompiled. The most difficult situations involve a language, runtime, operating system, or something else which is not available on Arm or would be difficult to run on Arm.

1.1 Survey your software stack

Step one in a typical migration journey is understanding the software stack. Make notes about operating system versions, programming languages, development tools, container tools, performance analysis tools, and any other important scripts included in the project. You can reference Migrating applications to Arm servers below for tips on how to get started - setting up a development machine, common challenges, and tips to proceed at pace.

Migrating applications to Arm servers

1.2 Discover Arm compatibility

Step two is to look through your scripts and build files and see if you spot architecture specific files. Software migration typically falls into 3 categories:

  1. Automatic: The Linux package manager installs software from the main repositories without any changes, totally seamless.
  2. Small modifications: Software installed using scripts or binary downloads requires minor changes to strings, such as changing “x86_64” and “amd64” to “arm64” or “aarch64”.
  3. Challenging: A few software projects still don’t support Arm Linux, some are well known projects like the Edge browser, and the others are smaller projects that haven’t added Arm support, yet. Some could be blockers and others may be easy to compile yourself.

You can quickly find out if software dependencies are available for Arm using the Software Ecosystem Dashboard for Arm link below - search for your package and find out which versions work on Arm and review the getting started tips. The dashboard is actively growing, and is a good place to understand if your software stack will run on Arm servers.

Software Ecosystem Dashboard for Arm.

1.3 Find resources to help

The below resources are curated to address migration challenges on specific cloud providers. Look through them for additional context.

Lastly, below are some specific migration helpers for various types of software:

Which software helps me build web applications on Arm servers?

Which networking software works on Arm servers?

SoftwareLearning PathsOther Content (Blogs/Videos)
VectorscanInstall Vectorscan (Hyperscan on Arm) and use it with Snort 3
DPDKDPDK Tuning Guide

STEP 2: Test, build, and run

Based on your initial research, decide how to proceed with trying your software on Arm. In general, you can use a top-down or bottom-up strategy to migrate to Arm. Select a methodology and use the resources above to build and run your application.

2.1 Top-down methodology

Top-down porting involves moving the complete software stack to an Arm machine and trying to build and run it straightaway. You will almost certainly face errors, which you can address one at a time until the full application runs on Arm.

Image Alt Text:Top-down porting methodology

This methodology is great for simpler stacks, when breaking down the problem would take more time than fixing errors iteratively.

2.2 Bottom-up methodology

Bottom-up porting is more systematic. Here, you break apart your software stack, starting with the foundations of your app to get those running on an Arm server first. Then add back one or two software packages at a time, and recompile and run to ensure it works on Arm. If errors arise, fix them or replace the incompatible package with an Arm compatible version. Continue building back your stack until it is fully formed on an Arm server.

Image Alt Text:Bottom-up porting methodology

This methodology is sensible for large stacks, where running the whole app on Arm immediately would cause too many errors to effectively work through.

STEP 3: Optimize your application

If you’ve reached this step, congratulations! Your application is running on Arm. The next action is to ensure it is running optimally.

3.1 Measure performance

Once the application is running you can measure performance. This can be as simple as timing an application or may involve using performance analysis tools.

You may have some performance analysis methodologies you already follow, continue to use those.

Below are some additional performance analysis tips and methodologies specific to Arm-based servers:

3.2 Ask for help

Your goal is to understand if the performance you see will translate into the expected price performance advantages. If you are unsure or need additional help you can ask the Arm developer community for help. Join the Arm Developer Program and talk directly to other developers and Arm Experts on Discord.

DELIVER: Deploy your application to users

Once the price performance gains are confirmed, you can plan for a larger deployment.

Deployment is outside the scope of this guide, but here are some concepts to keep in mind:

  • Experiment with different virtual machine sizes and instance types to find the best fit for your application.
  • Add some Arm nodes to your Kubernetes cluster and run a subset of workloads on Arm.
  • Direct some of your web traffic to an Arm version of the application.
  • Create a complete version of your application in a dev environment for additional testing.

Make sure to research the details needed for these tasks by checking any places you use infrastructure as code or other places you store details about virtual machine types and sizes, as well as parameters for managed services.

You can also check Works on Arm for the latest cloud and CI/CD initiatives for developers.

Summary

With this 3 step process and the provided resources, you are well positioned to migrate your applications to Arm. Happy porting!