オープンソースカーネルスケジューラでMeta広告サービスを刷新Modernizing the Meta Ads Service With an Open-Source Kernel Scheduler

Meta has detailed how it rebuilt part of its advertising serving infrastructure around an open-source Linux kernel scheduler, reporting measurable improvements in both latency and throughput. The work matters because ads serving is one of the company's most performance-sensitive and resource-intensive workloads, and because the underlying technology was developed in the open and contributed back to the wider Linux community rather than kept as a proprietary advantage.

At the center of the effort is sched_ext, an extensible scheduling framework that allows CPU scheduling policies to be written as BPF programs and loaded into a running kernel. Traditionally, the Linux CPU scheduler has been a fixed component compiled into the kernel; changing its behavior required patching kernel source, rebuilding, and rebooting fleets of machines. sched_ext changes that model by letting engineers express scheduling logic in safe, sandboxed BPF code that can be swapped in and out at runtime. If a custom policy misbehaves, the kernel can fall back to its built-in scheduler, which lowers the risk of experimenting in production. sched_ext was merged into the mainline Linux kernel in version 6.12, released in late 2024, after a lengthy review process, and Meta engineers were among its primary authors and advocates.

The practical appeal for a workload like ads serving is that a general-purpose scheduler must balance the needs of every possible application, while a purpose-built policy can be tuned to the specific characteristics of a single service. Ad ranking and delivery involves large numbers of threads competing for CPU time, with strict tail-latency requirements because slow responses can mean missed opportunities to serve a relevant ad. By using a scheduler such as scx_layered, which groups tasks into configurable layers with distinct scheduling behavior, operators can prioritize latency-critical work, improve cache locality, and reduce contention on shared resources. Meta reports that applying these techniques to its ads stack yielded gains that appear significant enough to justify the operational complexity, though the exact magnitude of the improvement is likely to vary across hardware generations and traffic patterns.

Understanding the change requires some context on how the Linux scheduler has evolved. For many years the default was the Completely Fair Scheduler, which was replaced in kernel 6.6 by EEVDF, or Earliest Eligible Virtual Deadline First, an algorithm designed to give better latency guarantees. Both are strong general-purpose choices, but neither can be deeply customized for an individual data-center workload without invasive kernel modifications. sched_ext does not aim to replace these schedulers so much as to provide a supported mechanism for rapid iteration and specialization, giving large operators a way to prototype ideas that might eventually influence the mainline scheduler itself.

The broader ecosystem around this work is worth noting. sched_ext builds on eBPF, the in-kernel virtual machine that has become a foundation for modern observability, networking, and security tooling, powering projects such as Cilium and a wide range of tracing utilities. A community collection of schedulers, often referred to as the scx project, includes implementations like scx_rusty, scx_lavd, and scx_bpfland, several of which are written partly in Rust and target different goals such as gaming responsiveness, server throughput, or energy efficiency. This reflects a wider industry trend of moving performance-critical logic into programmable kernel interfaces, and of hyperscalers contributing infrastructure improvements upstream so they can share maintenance costs and avoid diverging from the mainline kernel.

Contributing the work back to open source carries strategic as well as technical benefits. Upstreaming means Meta's custom scheduling logic can be validated by outside maintainers, benefit from community fixes, and remain compatible with future kernel releases, reducing the long-term burden of carrying private patches. It also gives other organizations a proven starting point, since the code has been exercised against real production traffic at large scale rather than only in synthetic benchmarks.

For readers evaluating similar approaches, the key takeaway is that programmable scheduling is maturing from research into production practice, but it remains an advanced technique. Realizing gains depends on careful workload profiling, willingness to maintain custom policies, and infrastructure to safely roll changes back. Meta's account suggests the trade-off can pay off for the largest and most latency-sensitive services, while remaining an emerging option for the broader industry.