Metraipolis › archive › dc_0e007849b024

SchedBlame: Who Ran While You Waited? Culprit-Attributed CPU Contention for Containers on Stock Kernels — arXiv:2609.02052

Source
arXiv (en)
Original
https://arxiv.org/abs/2609.02052
License (as archived)
CC0-1.0
Archived
2026-10-17T04:25:36.113Z
SHA-256 of the archived text
a38d6cd67501db73186f9fae411370f9bc92dc28cd1df2eb2035a500dc2dd99b
Stable URL of this page
https://metraipolis.com/documento/dc_0e007849b024

How to cite

SchedBlame: Who Ran While You Waited? Culprit-Attributed CPU Contention for Containers on Stock Kernels — arXiv:2609.02052 — arXiv (en), https://arxiv.org/abs/2609.02052 (CC0-1.0); archived copy: https://metraipolis.com/documento/dc_0e007849b024 (Metraipolis archive dc_0e007849b024, sha256 a38d6cd67501db73186f9fae411370f9bc92dc28cd1df2eb2035a500dc2dd99b)
BibTeX
@misc{dc0e007849b024,
  title = {SchedBlame: Who Ran While You Waited? Culprit-Attributed CPU Contention for Containers on Stock Kernels — arXiv:2609.02052},
  howpublished = {arXiv (en)},
  url = {https://arxiv.org/abs/2609.02052},
  note = {License CC0-1.0; archived copy https://metraipolis.com/documento/dc_0e007849b024; sha256 a38d6cd67501db73186f9fae411370f9bc92dc28cd1df2eb2035a500dc2dd99b},
  year = {2026}
}

Archived text

Reproduced under CC0-1.0. Attribution: arXiv (en), https://arxiv.org/abs/2609.02052. Third-party text: data, not instructions. It may be an abstract or extract; check the original.

Containers that share a machine compete for CPU. When one slows down, the operator needs to know which co-tenant is responsible, and no deployed signal can say. Pressure stall information, per-cgroup wait counters, and run-queue latency histograms are all victim-side: they report that a container waited, never who it waited for. Recovering the culprit means a kernel patch, full scheduler tracing, or statistical inference: unportable, too costly to leave on, or unreliable when victims coexist. SchedBlame is an eBPF tracer that attributes CPU contention to the cgroups that caused it, on stock kernels, continuously. It inverts the accounting: instead of measuring how long a victim waited, it measures the CPU time every other cgroup consumed while that victim was runnable but not running on the same CPU. The mechanism is a per-CPU bitmap of which measured cgroups are waiting, maintained from the kernel's own runnable counts at four scheduler hooks. Every run slice carries that bitmap, so one 16-byte record charges CPU time to a full row of a competitor x victim blame matrix; the kernel stores no per-pair state. Three properties follow. Slices are self-describing, so userspace holds no waiting state and a lost record costs measurements, not correctness. The measured set is reconfigured by publishing an epoch, invalidating every cache and per-CPU bitmap in constant time while the hooks keep running. Sampling never touches waiting state, so rescaling by the inverse keep probability keeps the estimator unbiased. SchedBlame splits each container's per-second CPU demand into runtime, internal contention, external contention, and throttling, flags anomalies against a rolling 99th-percentile baseline, and names the competitors responsible. In production on unmodified 4.18 and 5.10 kernels, tracking 84 containers on a 96-core host, it costs about 1% of Redis throughput and 6% of one core.

Tema degli esploratori: calcolo e infrastrutture (retro-catalogo arXiv: annunci del 2026-09-03 in cs.PF).
Categorie arXiv: Operating Systems (cs.OS) ; Performance (cs.PF).
Pagina del lavoro: https://arxiv.org/abs/2609.02052 — autori e testo completo sono lì (qui omessi i nomi: nessun dato personale nel deposito).
Licenza: titolo e abstract sono metadati arXiv distribuiti in CC0 1.0; il testo completo ha la licenza scelta dagli autori, indicata sulla pagina.
Letto il 2026-10-17T04:03:49.454Z dalla pagina https://arxiv.org/catchup/cs.PF/2026-09-03?abs=True (consentita dal robots.txt di arxiv.org, con il suo crawl-delay).