CachyOS Kernel: BORE-Scheduler, Sched-ext und Performance-Tuning erklärt

Der Linux-Kernel ist der kritischste Performance-Faktor für Gaming — und CachyOS macht ihn auswechselbar. Während andere Distros mit dem Standard-EEVDF-Scheduler ausgeliefert werden, bietet CachyOS den BORE-Scheduler, sched-ext (SCX) für Gaming-optimierte BPF-Scheduler, Thin LTO, AutoFDO-Profiling und CPU-spezifische Kompilierung.

Dieser Deep Dive erklärt, was diese Technologien bewirken und wie du sie für dein System konfigurierst.

CPU-Scheduler: Grundlagen

Der CPU-Scheduler entscheidet, welcher Prozess (Task) wann auf welchem CPU-Kern läuft. Für Gaming sind zwei Eigenschaften kritisch:

Latenz (Responsivität): Wie schnell kommt ein Spielprozess nach einer Pause wieder an die CPU? Hohe Latenz = Stutter, Mikroruckler.

Fairness vs. Burstigkeit: Ein "fairer" Scheduler gibt jedem Prozess gleich viel Zeit. Gaming braucht aber "Burstigkeit" — das Spiel darf kurz viel CPU fressen, dann wieder pause.

EEVDF: Der Standard-Linux-Scheduler

EEVDF (Earliest Eligible Virtual Deadline First) ist seit Linux 6.6 der Standard. Es ersetzt CFS (Completely Fair Scheduler) mit einer virtuellen Deadline-Queue. EEVDF ist excellent für Serverworkloads und allgemeinen Desktop — aber für Gaming-Responsivität gibt es bessere Optionen.

BORE-Scheduler verstehen

BORE (Burst-Oriented Response Enhancer) erweitert EEVDF um ein Burstiness-Konzept. Jeder Task bekommt einen Burstiness-Score basierend auf seinem historischen CPU-Verbrauchsmuster:

Burstiness = akkumulierte CPU-Zeit nach freiwilligem Verzicht
             (Sleep, IO-Wait, Yield)

Warum das für Gaming wichtig ist:

Ein Spielprozess schläft kurz (Wartet auf Vsync, IO) und braucht dann sofort maximale CPU. BORE erkennt dieses Muster und priorisiert solche "bursty" Tasks höher — sie bekommen ihre CPU-Zeit schneller als unter reinem EEVDF.

# BORE-Scheduler prüfen (CachyOS):
cat /sys/kernel/debug/sched/features | grep BORE
# BORE (vorhanden = aktiv)

# Welcher Scheduler läuft?
cat /proc/sys/kernel/sched_bore
# 1 = BORE aktiv

BORE-Parameter anpassen

# Aktueller BORE-Burstiness-Score (pro CPU):
cat /proc/sys/kernel/sched_bore

# BORE-Gewichtung erhöhen (aggressiver für Gaming):
sudo sysctl -w kernel.sched_bore=1

# Burstiness-Halbwertszeit (ms) — niedrigerer Wert = reaktiver:
cat /proc/sys/kernel/sched_burst_penalty_offset
# Standard: 22

# Dauerhaft setzen:
echo 'kernel.sched_bore=1' | sudo tee /etc/sysctl.d/99-bore.conf
echo 'kernel.sched_burst_penalty_offset=22' >> /etc/sysctl.d/99-bore.conf
sudo sysctl --system

BORE vs. EEVDF: Performance-Vergleich

Szenario	BORE	EEVDF
Gaming (Last-Szenarien)	✅ besser	⚠️ ruckelt
Gaming + Download gleichzeitig	✅ stabil	❌ Stutter
Serverworkload / Durchsatz	⚠️ minimal langsamer	✅ besser
Kryptografie (AES-Benchmark)	-7%	Referenz
Desktop-Responsivität	✅ sehr hoch	✅ gut

Sched-ext (SCX): Gaming-Scheduler zur Laufzeit

Sched-ext (seit Linux 6.12 mainline) ist das Revolutionäre: Du kannst den CPU-Scheduler zur Laufzeit durch BPF-Programme ersetzen — ohne Kernel-Neustart. CachyOS nutzt das scx_loader-System für einfache Konfiguration.

# Sched-ext aktiv?
cat /sys/kernel/sched_ext/root/ops
# NONE = Standard-Scheduler
# scx_lavd = LAVD-Scheduler aktiv

# Sched-ext-Service-Status:
systemctl status scx.service

SCX-Loader: Konfiguration

# Konfigurationsdatei:
cat /etc/scx_loader.toml

# /etc/scx_loader.toml

# Welcher Scheduler beim Systemstart aktiviert wird:
default_sched = "scx_lavd"

# Scheduler-Modus:
# "Auto"    = automatische Profil-Auswahl
# "Gaming"  = Gaming-optimiert
# "Server"  = Maximaler Durchsatz
# "Powersave" = Energiesparen
default_mode = "Gaming"

# Service neu starten nach Konfigurationsänderung:
sudo systemctl restart scx.service

# Aktuellen Scheduler anzeigen:
cat /sys/kernel/sched_ext/root/ops

# Scheduler-Statistiken:
scx_stats

Scheduler zur Laufzeit wechseln

# Auf scx_lavd wechseln (Gaming):
sudo systemctl stop scx.service
sudo scx_lavd --performance

# Auf scx_rusty wechseln (Allgemein):
sudo systemctl stop scx.service
sudo scx_rusty

# Zurück zum Standard (BORE/EEVDF):
# scx_loader-Service stoppen beendet alle SCX-Scheduler:
sudo systemctl stop scx.service
cat /sys/kernel/sched_ext/root/ops
# → NONE (BORE ist wieder aktiv)

SCX-Scheduler im Vergleich

scx_lavd — Gaming-Champion

LAVD (Latency-criticality Aware Virtual Deadline) wurde von Igalia im Auftrag von Valve für den Steam Deck entwickelt und ist der beste Scheduler für interaktive Workloads.

Kernfeature: Core Compaction

CPU-Last < 50% → aktive Kerne laufen länger + höhere Frequenz
                 inaktive Kerne: tiefer C-State (Schlaf)
→ Weniger Energieverbrauch, trotzdem hohe Responsivität

# scx_lavd mit Gaming-Profil starten:
sudo scx_lavd --performance

# Core Compaction deaktivieren (für Workstations):
sudo scx_lavd --no-core-compaction

# Statistiken anzeigen:
scx_lavd --stats

Realer Performance-Unterschied: In einem User-Bericht: Ghost of Tsushima + gleichzeitiges Rust-Compiling:

EEVDF: 15–20 FPS
scx_lavd: 54 FPS

scx_rusty — Flexibler Allrounder

scx_rusty bietet viele Tuning-Optionen und eignet sich gut für Multitasking-Szenarien (Gaming + Streaming + Downloads):

# scx_rusty mit Gaming-Balance:
sudo scx_rusty --slice-us-underutil 500 --slice-us-overutil 100

# Parameter:
# --nr-cpus-headroom: CPU-Reservierung für Hintergrundtasks
# --balance-load: Last-Balancing zwischen Kernen
sudo scx_rusty --nr-cpus-headroom 2

scx_bpfland — Niedrige Latenz

# scx_bpfland: Guter Gaming-Scheduler für gleichmäßige Latenz
sudo scx_bpfland

# Mit Debug-Ausgabe:
sudo scx_bpfland -v

Scheduler-Empfehlungen

Use Case	Empfehlung
Reines Gaming	`scx_lavd` + Gaming-Profil
Gaming + Streaming	`scx_lavd` oder `scx_rusty`
Gaming + viel Hintergrundarbeit	`scx_rusty`
Steam Deck / Handhelds	`scx_lavd` (von Valve entwickelt!)
Server / Durchsatz	EEVDF (Standard)
Laptop / Energiesparen	`scx_lavd` (Core Compaction!)

CachyOS Kernel Manager

Der CachyOS Kernel Manager ist eine grafische Oberfläche zur Verwaltung von Kerneln und Schedulern.

# Kernel Manager öffnen:
cachyos-kernel-manager
# oder: im Startmenü suchen

Kernel-Varianten

Kernel	Beschreibung	Wann nutzen?
`linux-cachyos`	Standard, BORE, x86-64-v3	Empfohlen für alle
`linux-cachyos-lts`	LTS-Basis, BORE	Maximale Stabilität
`linux-cachyos-rc`	Release Candidate	Testen neuer Features
`linux-cachyos-rt`	Real-Time + BORE	Audio-Produktion, RT
`linux-cachyos-bore`	Nur BORE, kein SCX	Wenn SCX Probleme macht
`linux-cachyos-hardened`	Sicherheitshärtung	Security-First

# Aktuell installierten Kernel anzeigen:
pacman -Q linux-cachyos
uname -r

# Kernel-Manager installiert/wechselt Kernel mit GUI
# Oder manuell:
sudo pacman -S linux-cachyos linux-cachyos-headers

SCX via Kernel Manager

Im Kernel Manager:

Sched-ext Scheduler Config → Auswählen
→ Scheduler: scx_lavd
→ Modus: Gaming
→ Anwenden

Kernel-Parameter tunen

Tick-Rate (HZ)

CachyOS Kernel ermöglicht verschiedene Tick-Raten:

HZ	Beschreibung	Wann nutzen?
1000 Hz	Höchste Responsivität	Gaming
500 Hz	Balance	Desktop
300 Hz	Compromise	Allgemein
100 Hz	Server-optimal	Server
tickless	Dynamisch	Energiesparen

# Aktuelle Tick-Rate prüfen:
grep CONFIG_HZ /boot/config-$(uname -r)
# CONFIG_HZ=1000

# CachyOS Standard: 1000 Hz
# Beim Kernel-Wechsel im Kernel Manager auswählbar

Preemption Model

# Aktuelles Preemption-Modell:
grep CONFIG_PREEMPT /boot/config-$(uname -r)
# CONFIG_PREEMPT_VOLUNTARY=y   (Standard)
# oder: CONFIG_PREEMPT=y        (Full Preemption — geringste Latenz)

# Für Gaming: PREEMPT_FULL oder PREEMPT_VOLUNTARY
# Kernel Manager: Preemption → Full (höchste Responsivität)

Wichtige Sysctl-Parameter für Gaming

# /etc/sysctl.d/99-gaming.conf erstellen:
sudo nano /etc/sysctl.d/99-gaming.conf

# Gaming-optimierte Sysctl-Einstellungen

# VM: Weniger aggressives Swapping (0=nie swappen, 10=minimal)
vm.swappiness=10

# VM: Dirty Pages Writeback (mehr Daten im RAM bevor Write)
vm.dirty_ratio=10
vm.dirty_background_ratio=5

# Netzwerk: Buffer für Gaming
net.core.rmem_max=16777216
net.core.wmem_max=16777216

# Huge Pages für bessere Speicherverwaltung:
vm.nr_hugepages=128

# Inotify: Viele Dateien beobachten (für Spiele-Assets):
fs.inotify.max_user_watches=524288

# Split-Lock-Mitigation deaktivieren (Performance, nicht empfohlen auf Shared-Systemen):
# kernel.split_lock_mitigate=0

sudo sysctl --system

LTO und AutoFDO

Thin LTO (Link-Time Optimization)

CachyOS kompiliert den Kernel mit Thin LTO — der Linker optimiert über Modulgrenzen hinweg:

# LTO im Kernel-Config prüfen:
grep CONFIG_LTO /boot/config-$(uname -r)
# CONFIG_LTO_CLANG_THIN=y   (Thin LTO mit Clang)

# Auswirkung: 5–15% bessere Code-Dichte im Kernel
# → weniger CPU-Cache-Misses, bessere Branch-Prediction

AutoFDO / Propeller Profiling

CachyOS nutzt Feedback-basierte Optimierung:

AutoFDO: Profildaten aus echten Workloads → Compiler optimiert Hot-Paths
Propeller: Optimiert Funktions-Layout im Binary für bessere Cache-Nutzung

Dies ist transparente Infrastruktur — kein User-Setup nötig, die Optimierungen sind in den Paketen enthalten.

Kernel auf Arch Linux (ohne CachyOS)

Der CachyOS-Kernel ist auch auf Standard-Arch Linux installierbar:

# CachyOS-Repository zu Arch hinzufügen:
sudo nano /etc/pacman.conf

# Ganz oben (vor [core]) einfügen:
[cachyos]
Include = /etc/pacman.d/cachyos-mirrorlist

[cachyos-v3]
Include = /etc/pacman.d/cachyos-v3-mirrorlist

# Schlüssel importieren:
sudo pacman-key --recv-keys F3B607488DB35A47 --keyserver keyserver.ubuntu.com
sudo pacman-key --lsign-key F3B607488DB35A47

# CachyOS-Keyring und Mirrorlist installieren:
sudo pacman -U 'https://cdn-mirror.cachyos.org/repo/x86_64/cachyos/cachyos-keyring-*.pkg.tar.zst' \
             'https://cdn-mirror.cachyos.org/repo/x86_64/cachyos/cachyos-mirrorlist-*.pkg.tar.zst' \
             'https://cdn-mirror.cachyos.org/repo/x86_64/cachyos/cachyos-v3-mirrorlist-*.pkg.tar.zst'

sudo pacman -Sy

# linux-cachyos installieren:
sudo pacman -S linux-cachyos linux-cachyos-headers

# GRUB-Konfiguration updaten:
sudo grub-mkconfig -o /boot/grub/grub.cfg

Benchmarking und Messung

Scheduler-Latenz messen

# cyclictest: RT-Latenz messen (niedrigere Latenz = besser):
sudo apt install rt-tests   # Ubuntu
sudo pacman -S rt-tests     # Arch

# 10 Sekunden Test:
sudo cyclictest --mlockall -t5 -p95 -i200 -h400 -q --duration=10s

# Ausgabe: Max-Latenz in µs
# EEVDF: oft 200–500 µs
# BORE:  oft 100–250 µs
# scx_lavd: oft 50–150 µs

Gaming-Benchmark: Phoronix Test Suite

# Phoronix Test Suite installieren:
sudo pacman -S phoronix-test-suite   # Arch
sudo apt install phoronix-test-suite  # Ubuntu

# Gaming-relevante Tests:
phoronix-test-suite benchmark pts/compress-7zip
phoronix-test-suite benchmark pts/vulkan
phoronix-test-suite benchmark pts/unigine-superposition

Scheduler-Wechsel live benchmarken

# Benchmark-Skript für Scheduler-Vergleich:
#!/bin/bash
for scheduler in "NONE" "scx_lavd" "scx_rusty"; do
  if [ "$scheduler" == "NONE" ]; then
    sudo systemctl stop scx.service 2>/dev/null
  else
    sudo systemctl stop scx.service 2>/dev/null
    sudo $scheduler &
    sleep 2
  fi

  echo "=== Scheduler: $scheduler ==="
  # 7zip Benchmark (CPU-Multi-Thread):
  7z b -mmt$(nproc) | grep "Tot:"
  sleep 1
done

Fazit

Der CachyOS-Kernel ist mehr als ein gepatchter Mainline-Kernel — er ist ein vollständiges Performance-Framework. BORE liefert messbar bessere Gaming-Responsivität als EEVDF, sched-ext/scx_lavd (von Valve für den Steam Deck entwickelt!) geht noch weiter, und LTO + AutoFDO machen jeden Kernel-Code-Pfad schneller.

Kategorien

Linux Einstieg & Umstieg

Distributionen & Paketmanagement

Linux Grundlagen & Terminal

Container & DevOps

Systemadministration

Entwicklungsumgebung

Security & Hardening

Troubleshooting & Performance

No results found