Using ARM on Coiled#

Coiled supports ARM (Graviton) instance types on AWS.

We found that for some workloads, ARM is significantly faster and cheaper. We don’t yet know how to predict whether a specific workload will be better on ARM, but we encourage you to try for yourself!

Spinning up an ARM cluster on AWS is almost no different from spinning up a non-ARM cluster. You can use Package Synchronization, coiled.create_software_environment(), or your own pre-built Docker image. (Note that if using your own Docker image, it does need to be built for Linux/arm64 platform.)

Starting a cluster using package sync#

The easiest method to working with ARM is to create a Cluster instance as you would normally with Package Synchronization. The only difference is that you specify an ARM instance type for your workers and scheduler.

cluster = coiled.Cluster(
    # ARM instance types for scheduler and workers
    arm=True,
    n_workers=10,
)

That will mirror your local Python environment on the cluster, even if your machine is not a Linux ARM machine.

Note

Package sync and create_software_environment support for ARM was added in Coiled version 0.6.0. If you’re using Python 3.8, note that you’ll need python<=3.8.16 because 3.8.16 doesn’t have a build of cpython on conda-forge (which is how we install Python on cluster). Python 3.9 and higher work fine.

Using a custom Docker image#

You can use GitHub Actions to build your own multi-arch (x86 and ARM) Docker image (see this example yaml file).

Locally, you can build multi-arch images like this:

docker buildx build --platform linux/arm64,linux/amd64 \
-t <your-image-name>:latest --push .

You can then upload your local image to wherever you usually store Docker images (e.g. Docker Hub or Amazon ECR) and create a Coiled Python environment using this image (see Docker images for instructions).

Instance types#

When creating a cluster, specifying arm=True will default to requesting m7g.xlarge (first choice) and t4g.xlarge (second choice) instance types. You can also request specific instance types, however, multi-architecture clusters are not currently supported.

cluster = coiled.Cluster(
    # ARM instance types for scheduler and workers
    scheduler_vm_types=["t4g.large"],
    worker_vm_types=["c7g.xlarge"],
    n_workers=10,
)

For common Intel instance types you might be using already, there’s a roughly equivalent ARM instance type you could try instead.

Intel	ARM	Description
t3	t4g	burstable (best for interactive/non-compute-intensive work)
m6i	m7g	non-burstable balanced compute/memory (sensible default for common workloads)
c6i	c7g	compute-optimized (higher ratio of vCPUs to memory)
r6i	r7g	memory-optimized (higher ratio of memory to vCPUs)

The *7g families have Graviton 3 and are slightly more expensive than corresponding *6g family with older generation ARM processor, though Graviton 3 is significantly better and is still cheaper (typically by 15%) than corresponding Intel instance type.

GPUs

Configuration