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.

What cloud hardware is available today?

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

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.

• Porting architecture specific intrinsics - perfect for porting intrinsics from another architecture.

• Arm software install guides - good for quickly installing common tools and software.

• simd.info - a searchable reference tool for C intrinsics for SIMD engines.

• Arm Infrastructure Solutions blog - an Arm-specific technical blog.

• Arm Learning Paths for Servers and Cloud - general tutorials for Arm servers. You can search for specific cloud service providers, including AWS , Google Cloud , Microsoft Azure , and Oracle .

• AWS has additional resources such as the Porting Advisor for Graviton and AWS Graviton Technical Guide .

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

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.

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.

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:

• Learn the Arm Neoverse N1 performance analysis methodology
• Profiling for Neoverse with Streamline CLI Tools
• Learn how to optimize an application with BOLT
• How to use the Arm Performance Monitoring Unit and System Counter
• NVIDIA Grace CPU Benchmarking Guide
• Learn about Large System Extensions (LSE)

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!