Web performance
AMD Capacity Aware Scheduling: Fixing Hybrid Ryzen Task Placement in amd-pstate for Linux 7.5
Without per-CPU capacity metrics, the Linux scheduler treats hybrid AMD performance and efficiency cores as interchangeable. AMD's newly posted amd-pstate Capacity Aware Scheduling patches expose asymmetric per-CPU capacities ahead of Linux v7.5—see how the architecture works and how to audit or override it with amd_case=disable.
8 min read
AMD Capacity Aware Scheduling: Fixing Hybrid Ryzen Task Placement in amd-pstate for Linux 7.5
Executive Summary
On November 14, 2026 (reported by Phoronix on November 15, 2026), AMD posted a new Linux kernel patch series enabling Capacity Aware Scheduling (CAS) for AMD heterogeneous and hybrid processors via the amd-pstate CPU performance scaling driver. Targeted for review ahead of the upcoming Linux v7.5 kernel cycle, the patches address a long-standing scheduling gap: amd-pstate currently exports no per-CPU capacity values to the Linux scheduler.
Because amd-pstate omits per-CPU capacity metrics today, the Completely Fair Scheduler (CFS) and EEVDF scheduler see every logical CPU on a hybrid Ryzen processor as having identical capacity. As AMD's patch description explains, this causes the scheduler to treat performance and efficiency cores as interchangeable—placing and balancing tasks without regard to core strength, which degrades both multi-threaded throughput and energy efficiency on hybrid systems.
The new patch series instructs amd-pstate to publish asymmetric per-CPU capacities and enables Capacity Aware Scheduling by default on capable AMD hardware. Administrators and kernel testers who need to revert to legacy uniform-capacity behavior can pass a new amd_case=disable kernel boot parameter. While Phoronix and daily.dev note that the work is also aimed at supporting an additional low-power core type expected in upcoming Zen 6 Ryzen SKUs, empirical before-and-after benchmarks on shipping hybrid hardware are not yet available until the patches are reviewed and tested.
The Hybrid Scheduling Gap in amd-pstate
Under Linux's amd-pstate CPU Performance Scaling Driver, frequency management relies on ACPI Collaborative Processor Performance Control (CPPC) rather than legacy 3-state ACPI P-states. CPPC replaces coarse-grained hardware P-states with a continuous, abstract, unit-less performance scale that lets software express performance hints relative to processor infrastructure limits.
Depending on the platform, amd-pstate initializes one of two hardware backends: Full MSR Support (indicated by X86_FEATURE_CPPC, which enables low-latency register updates directly in interrupt context via pstate_xxx callbacks) or Shared Memory Support (using cppc_acpi helpers when X86_FEATURE_CPPC is absent). If the ACPI SBIOS lacks a valid _CPC entry (acpi_cpc_valid()), amd-pstate initialization fails cleanly and the kernel falls back to acpi-cpufreq.
The driver supports three operation modes:
- Autonomous (
active) mode: The platform ignores the OS Desired Performance register and governs frequency using minimum performance, maximum performance, and Energy Performance Preference (EPP) hints. - Non-autonomous (
passive) mode: The OS directly sets the Desired Performance register; when paired with theschedutilgovernor,amd-pstateregistersadjust_perfandsugov_update_single_perfviacpufreq_update_utilto translate scheduler utilization directly into CPPC performance targets. - Guided-autonomous (
guided) mode: Hardware selects operating performance autonomously within minimum and maximum bounds supplied by the OS.
Until now, amd-pstate addressed core heterogeneity primarily through Preferred Core (amd_prefcore), which reads the CPPC highest performance capability register to rank cores that can reach higher frequencies at lower voltages. However, as documented in the Linux Kernel Capacity Aware Scheduling specification (sched-capacity.html), core ranking alone is not the same as asymmetric CPU capacity:
- Preferred Core (
amd_prefcore) provides a relative frequency/boost preference ordering among cores—useful when a subset of identical-microarchitecture cores can boost higher due to silicon quality or thermal headroom. - Capacity Aware Scheduling (CAS) requires normalized per-CPU capacity values (
arch_scale_cpu_capacity()) representing the maximum sustained performance each core can deliver relative to the most performant CPU in the system (max_capacity).
When a processor combines distinct core types—such as full-size Performance cores and compact Efficiency or low-power cores whose maximum sustained performance and frequency differ—omitting per-CPU capacity leaves the scheduler blind to the performance delta. Heavy CPU-bound threads can be scheduled onto lower-capacity efficiency cores while light background tasks occupy high-capacity performance cores, and Per-Entity Load Tracking (PELT) utilization signals cannot be normalized across heterogeneous cores.
Technical Mechanics & Architecture
How Linux Capacity Aware Scheduling Works
Per the Linux Kernel Capacity Aware Scheduling documentation, heterogeneous scheduling depends on three coupled invariants:
- Normalized CPU Capacity (
capacity_orig): Each CPU is assigned an original capacity normalized against the fastest core in the system (1024by kernel convention forSCHED_CAPACITY_SCALE). Disparity stems from microarchitectural differences (IPC per Hz) and maximum sustainable Operating Performance Points (DVFS limits). - Frequency & CPU Invariance: Task utilization is scaled both by current frequency (
arch_scale_freq_capacity(), viaAPERF/MPERFcounters on x86) and by CPU capacity (task_util_cpu_inv(p) = duty_cycle(p) * (capacity(cpu) / max_capacity)). Without CPU-invariant scaling, a task consuming 75% duty cycle on aC/3efficiency core appears three times "heavier" than the same task consuming 25% duty cycle on a full-capacityCperformance core. - Topology Discovery (
sched_asym_cpucapacity): When the kernel buildssched_domainhierarchies and detects asymmetric per-CPU capacities, it activates thesched_asym_cpucapacitystatic key and setsSD_ASYM_CPUCAPACITYon scheduling domains spanning mixed core types.
+-----------------------------------------------------------------------+
| AMD HYBRID CPU (P-CORES + E-CORES / LP-CORES) |
| |
| [ Performance Cores ] [ Efficiency / LP Cores ] |
| Max Sustained Perf: C Max Sustained Perf: C/N |
| CPPC Highest/Nominal Perf CPPC Highest/Nominal Perf |
+------------+---------------------------------------------+------------+
| |
v v
+-----------------------------------------------------------------------+
| amd-pstate CPPC DRIVER (x86) |
| |
| * Publishes asymmetric per-CPU capacity (enabled by default) |
| * Boot override: amd_case=disable (reverts to uniform capacity) |
| * Complements existing amd_prefcore=disable & active/passive/guided |
+-----------------------------------+-----------------------------------+
| arch_scale_cpu_capacity()
v
+-----------------------------------------------------------------------+
| LINUX SCHEDULER (sched_asym_cpucapacity) |
| |
| 1. Capacity Fitness: task_util(p) < capacity(task_cpu(p)) |
| 2. Misfit Migration: Moves CPU-bound tasks from E-cores -> P-cores |
| 3. uclamp Bounds: clamp(util, uclamp_min, uclamp_max) < cap(cpu) |
+-----------------------------------------------------------------------+
Capacity Fitness and Misfit Task Migration
Once amd-pstate populates asymmetric per-CPU capacities and sched_asym_cpucapacity is active, the Linux scheduler enforces the capacity fitness criterion (task_util(p) < capacity(task_cpu(p))) during task wakeup and load balancing:
- Wakeup CPU selection: Tasks whose estimated PELT utilization (bounded by
uclamp.minanduclamp.max) exceeds an efficiency core's capacity are steered directly to a performance core. Conversely, low-utilization periodic tasks fit comfortably on efficiency cores, preserving power and thermal headroom for performance cores. - Misfit task migration: If a task initially wakes up with low estimated utilization on an efficiency core and subsequently becomes CPU-bound (
task_util(p) > capacity(task_cpu(p))), the scheduler flags it as a misfit task. During periodic or active load balancing, the balancer migrates the misfit task to a higher-capacity performance core even if no further wakeup events occur.
Boot-Time Control: amd_case=disable
Just as amd-pstate provides amd_prefcore=disable to let administrators ignore CPPC preferred-core rankings, the November 2026 patch series introduces amd_case=disable. Passing amd_case=disable on the kernel command line suppresses asymmetric per-CPU capacity publication, allowing operators to A/B test scheduler behavior, isolate regressions on specific BIOS/SBIOS firmware revisions, or fall back to uniform-capacity scheduling if a latency-sensitive workload exhibits unexpected migrations.
Evidence & Kernel Readiness Assessment
- Problem Statement & Patch Scope (High Confidence): Both Phoronix and daily.dev quote AMD's November 14, 2026 patch cover text verbatim:
amd-pstatedoes not currently export per-CPU capacity information, causing the scheduler to treat performance and efficiency cores as interchangeable and hurting both throughput and energy efficiency. - Upcoming Zen 6 Hybrid Hardware Alignment (Moderate Confidence): Phoronix notes that while existing hybrid Ryzen processors already benefit from distinguishing performance and efficiency cores, the patch series is particularly relevant for an upcoming low-power core type believed to be part of certain Zen 6 Ryzen SKUs.
- Linux v7.5 Integration Timeline (Pending Upstream Review): The patches were posted for community review on November 14, 2026, targeting the Linux v7.5 merge window. Final inclusion depends on upstream scheduler and
cpufreqmaintainer review. - Empirical Performance Benchmarks (Unavailable): Neither AMD's patch announcement nor Phoronix has published
tbench,gitsource, SPEC, or power-efficiency benchmark deltas for the newamd-pstateCAS implementation yet.
Operational & Tuning Playbook
For Linux systems engineers, kernel maintainers, and performance teams running hybrid AMD Ryzen laptops, workstations, or edge servers, here is how to audit current amd-pstate behavior today and prepare for the Linux 7.5 CAS rollout:
- Verify Active
amd-pstateDriver & Operation Mode: Confirm your system is runningamd-pstate(rather thanacpi-cpufreqfallback) and inspect the active mode (active,passive, orguided) via sysfs. - Check
amd-pstate-utKernel Selftests: Use the built-inamd-pstate-utmodule documented in amd-pstate.rst to validate_CPCACPI tables, driver enablement, and CPPC performance/frequency scaling before testing scheduler patches. - Inspect Scheduler Domain Asymmetry &
uclampPolicies: Once running a kernel with the CAS patches, verify whether asymmetric capacity domains are active and useuclamp(sched_setattr()orcgroup v2cpu.uclamp.min/cpu.uclamp.max) to pin latency-critical threads to performance cores or constrain background batch jobs to efficiency cores. - Stage Rollback via
amd_case=disable: Add a GRUB/systemd-boot fallback entry containingamd_case=disablewhen testing Linux 7.5 release candidates so you can immediately isolate scheduler regressions without recompiling the kernel.
Below is a safe, read-only diagnostic script for Linux operators to audit amd-pstate status, CPPC scaling limits, and uclamp / scheduler capacity state on a live host:
#!/usr/bin/env python3
"""Read-only audit of amd-pstate driver mode, CPPC bounds, and sysfs CPU capacity."""
from pathlib import Path
def read_sysfs(path: Path, default: str = "N/A") -> str:
try:
return path.read_text().strip()
except OSError:
return default
def main() -> None:
pstate_status = read_sysfs(Path("/sys/devices/system/cpu/amd_pstate/status"))
prefcore = read_sysfs(Path("/sys/devices/system/cpu/amd_pstate/prefcore"))
print(f"amd_pstate status: {pstate_status} | prefcore: {prefcore}")
cpu_dirs = sorted(Path("/sys/devices/system/cpu").glob("cpu[0-9]*"),
key=lambda p: int(p.name[3:]))
for cpu in cpu_dirs[:16]: # Inspect first 16 logical CPUs
driver = read_sysfs(cpu / "cpufreq/scaling_driver")
max_freq = read_sysfs(cpu / "cpufreq/scaling_max_freq")
cap = read_sysfs(cpu / "cpu_capacity")
print(f"{cpu.name:6s} | driver={driver:14s} | max_khz={max_freq:8s} | cpu_capacity={cap}")
if __name__ == "__main__":
main()
Frequently Asked Questions (FAQ)
What problem do AMD's new Capacity Aware Scheduling patches solve?
Currently, the amd-pstate driver does not publish per-CPU capacity values to the Linux kernel scheduler. As a result, the scheduler treats performance and efficiency cores on hybrid AMD processors as identical, hurting both throughput and energy efficiency (Phoronix).
How is Capacity Aware Scheduling different from amd-pstate Preferred Core?
Preferred Core (amd_prefcore) communicates a relative boost/frequency ranking among cores via CPPC's highest performance register (Linux Kernel Docs). Capacity Aware Scheduling exposes normalized maximum sustained per-CPU capacities (arch_scale_cpu_capacity()) so the scheduler can enforce capacity fitness and trigger misfit task migration across heterogeneous core microarchitectures (sched-capacity.html).
Is Capacity Aware Scheduling enabled by default, and how can it be disabled?
Yes. On capable hybrid AMD hardware, the patches enable Capacity Aware Scheduling by default, and administrators can disable it at boot using the amd_case=disable kernel parameter (Phoronix).
Which Linux kernel version is targeted for these patches?
The patches were posted on November 14, 2026, with Phoronix noting they could be reviewed and queued in time for the Linux v7.5 kernel cycle.
Are benchmarks available showing the performance impact of amd-pstate CAS?
Not yet. As of November 15, 2026, the patches have just been posted for review and no official or independent benchmark comparisons have been published.
Sources
- Phoronix — AMD Posts Linux Patches For Capacity Aware Scheduling On Hybrid CPUs (November 15, 2026)
- The Linux Kernel Documentation — Capacity Aware Scheduling (
sched-capacity.html) - The Linux Kernel Documentation — amd-pstate CPU Performance Scaling Driver (
amd-pstate.html) - daily.dev — AMD Posts Linux Patches For Capacity Aware Scheduling On Hybrid CPUs (November 15, 2026)