Benchmark: Linux kernel builds 3-68x faster on Avrea than GitHub Actions
On GitHub Actions, a Linux kernel build takes 27 minutes 23 seconds. On Avrea, the same build, with the same two vCPUs: 9 minutes 3 seconds, 24 seconds with a warm cache.
Why the Linux kernel
The Linux kernel is one of the most well known open source C codebases. It is also very large at over 40M lines of code. Building the kernel from scratch is a commonly used benchmark to measure the speed of a system.
How we ran the test
We used the same runner spec (2 vCPU, 7.8 GiB, Ubuntu 24.04) and the same kernel commit for both Avrea and GitHub. We ran make defconfig && make -j2. defconfig is used to configure the build and -j2 to set the number of parallel compile/link processes to two since we ran the test on two vCPUs.
For the cached run, we used ccache. On Avrea ccache is configured automatically to use Avrea’s build cache as the backing store.
GitHub Actions has no equivalent cache service, although you could wire GitHub Actions cache to ccache using an adapter. That approach has two challenges: 1) GHA cache is not very fast (see how we made GHA cache fast), and 2) GHA cache is much better suited for a small amount of large files than thousands and thousands of small files generated by a c compiler.
Below is a self-contained example workflow of what we are measuring.
name: "Linux Kernel"
on:
workflow_dispatch:
env:
PROJECT_REPO: "https://github.com/torvalds/linux.git"
PROJECT_TAG: "v6.19"
jobs:
build:
runs-on: avrea-ubuntu-latest-2-vcpu
env:
CCACHE_COMPILERCHECK: content
steps:
- name: Clone project
run: git clone --depth 1 --branch ${{ env.PROJECT_TAG }} ${{ env.PROJECT_REPO }} linux
- name: Install build deps
run: sudo apt-get update && sudo apt-get install -y ccache flex bison libelf-dev libssl-dev bc
- name: Build
working-directory: linux
run: |
make defconfig
make -j2Results
Hardware alone makes the build 3x faster. ccache with Avrea’s build cache makes a warm build finish in 24 seconds.
Why it's faster
As the chart above shows, a no-cache kernel build basically maxes out any amount of CPU cores you have available. The build also writes tens of thousands of object files to /tmp, which the link step then reads, so a fast disk doesn’t hurt either.
Avrea’s 2 vCPU runner gets a score of ~6500 in single-core sysbench. GitHub gets ~3700. Disk write speed difference is even bigger: ~4 GB/s on Avrea, ~220 MB/s on GitHub.
ccache hashes each compilation’s inputs (the preprocessed source, compiler flags, etc.) and caches the output. If a compilation’s hash matches later, ccache hands back the cached object and the compiler never runs.
Kernel builds are well-suited to ccache. Between reasonable commits, most translation units receive identical preprocessor output, so the warm-run hit rate stays very high.
Avrea’s build cache is co-located with the runners, so every ccache lookup reads from a nearby object store. The whole build finishes in 24 seconds. It’s important to note here that the cache stays warm between runs, so subsequent commits/pushes build fast because the code is mostly the same as on the previous run.
Another way to make the build fast is just to throw more hardware at it. On an avrea-ubuntu-latest-32-vcpu machine the build takes 60s without any caching. In the openbenchmarking.org ranking it sits just below the Intel Core Ultra 7 270k Plus’s 53s. The 270k is Intel’s current flagship gaming CPU.
On Avrea you get both: fast hardware and out-of-the-box caching to make your builds go really fast.
Other benchmarks in this series
- Bazel (39.7x)
- Ghostty (27x)
- Kafka (6.6x)
- Next.js (142x)
- RisingWave (11.5x)
About Avrea
Avrea is a drop-in replacement for GitHub Actions runners. Update the runs-on label in your workflow and the build moves over.
Runs come with CPU and memory metrics, searchable log history, and a way to SSH into the running VM.
