Container launch speed on a 96-core Linux server dropped to 18 per second, then rose to 43 per second when half the cores were taken away. Benchmarks on an Intel Xeon 6731E machine show how a single kernel lock can make extra hardware slow a workload down.
The kernel, containerd version, image and one-worker-per-core setup were identical in both runs. The 48 extra cores weren’t idle. They stayed busy throughout, spinning while they waited for a lock that a single core could own at any moment.
The lock behind the stall
Netflix engineers hit the same wall in November 2025, with nodes freezing for tens of seconds during mass container starts. Kernel mount locks, shared by the entire machine, were to blame. Netflix and the containerd project then redesigned the code path to skip most mounts, and the result landed in containerd 2.2.
The trigger is user namespaces. Each container’s root filesystem is an overlayfs mount stacked from image layers. Give every container a private block of host user IDs, and the layers have to look owned by that block. Idmapped mounts are the kernel feature that does this.
Through containerd 2.1, each layer got its own idmapped bind mount, torn down again afterward. That is three system calls plus an unmount per layer, all taking locks that span every mount namespace. Starting 100 containers from 50-layer images adds up to 20,200 operations queued one behind another.
How the test ran
The test machine has one Xeon 6731E socket with 96 cores, SMT off, a single NUMA node and 250 GB of RAM, on Ubuntu 24.04. The benchmark was containerd’s own stress tool, modified to request user namespaces. Each worker creates a container, starts it, waits for it to exit and deletes it, so the work is nearly all setup and teardown. The image was an Alpine base plus 50 layers, with state on tmpfs and runc 1.5.3. Each configuration ran twice for 20 seconds.
One kernel tops out near 20 launches a second
Without user namespaces the kernel scaled well, from about 5 containers a second at one worker to roughly 280 at 48 workers. Add user namespaces on containerd 2.1.4 and throughput topped out at 18 a second by 16 workers, then stayed flat.
Profiling 96 workers showed 21% of CPU cycles burned waiting on the namespace_sem write lock, plus 13% lost to spinlock contention. Giving cores 48 to 95 to an idle second kernel left the host with 48 cores, and it started over twice as many containers. More contenders make the lock change hands more slowly.
The userspace fix worked best
containerd 2.2 maps the shared parent folder of all layers a single time, so layer count stops driving the number of mounts. For this image, each container needed about 155 move_mount calls on 2.1.4 and 3 on 2.2.10. On all 96 cores, throughput went from 18 to about 250 per second, a 14x gain from a software change. Teams on containerd 2.2 or newer don’t face the 20-a-second ceiling at all.
Splitting the machine in two
The other experiment boots a second Linux kernel on a subset of cores and memory, with no hypervisor, which means it keeps a separate mount table and a separate namespace_sem. On containerd 2.1.4, two kernels together started 140 containers a second, compared with 18 for one. On 2.2.10 the figures were 360 and 252, a 1.4x edge.
That comparison tilts toward the split, since the host carries systemd, AppArmor and a full distribution while the second kernel has a bare Alpine userland. A fairer test pitted two 44-core instances against one 88-core instance. The pair won by 2.3x on the old containerd and 1.4x on the new. The best number overall was 381 launches a second, from the fixed containerd on two kernels.
Limits of the results
The caveats are real. Only one socket was tested, and a contended lock likely hurts more when its cache line has to cross sockets. The benchmark is a launch loop, so long-running containers never feel any of this. Runs were short, and the user-namespace option is a local patch. One cell in the results is empty because a benchmark client hung.
Bursty nodes, batch and CI systems, and platforms that spin up a container per request stand to gain the most. To see the effect locally, run a user-namespaced workload on containerd 2.1 with a worker per core, then again with half the cores offline. Teams on older versions should upgrade first: that change delivered a 14x gain, against 2.3x for splitting the kernel.
Source: Multikernel Technologies