What is Linux Pressure Stall Information (PSI) and how does it detect resource exhaustion before the system freezes?

Historically, Linux administrators monitored load averages and raw resource utilization (e.g. 95% CPU or 98% RAM). However, high utilization does not necessarily mean an application is degraded (e.g. a database utilizing 99% RAM for hot page caching is healthy, not starved). Pressure Stall Information (PSI), merged in Linux 4.20 by Facebook engineers, introduces an accurate metric of resource contention by measuring lost time: the percentage of wall-clock time that tasks are stalled waiting for CPU runqueues, memory reclaim/paging, or block I/O. PSI exposes these stalls via /proc/pressure/{cpu,memory,io} across 10-second, 60-second, and 300-second rolling exponential decay averages, alongside a cumulative microsecond stall counter. System daemons can configure threshold triggers using poll() or epoll() on file descriptors, enabling millisecond-speed proactive shedding or pod scaling before the system experiences hard lockup.

What is the critical mathematical distinction between "some" and "full" PSI metrics?

The PSI interface reports two distinct stall percentages: (1) some: Measures the percentage of time where at least one non-idle task is delayed waiting for a resource, even while other CPU cores remain productive. A moderate "some" value (e.g. 15% memory some) indicates minor page reclaim or swap I/O occurring concurrently with useful work; (2) full: Measures the catastrophic condition where all runnable tasks on a CPU are simultaneously stalled on memory allocation or disk I/O, leaving the CPU completely idle with zero productive user or system work being performed. A non-zero "full" metric represents pure CPU waste and severe system thrashing. Note that CPU pressure only has a "some" metric because one task being stalled on CPU scheduling means another task is actively executing on the CPU (hence all tasks cannot be stalled on CPU simultaneously).

How does cgroups v2 unify the fractured multi-hierarchy architecture of cgroups v1?

In cgroups v1, each kernel resource controller (cpu, memory, blkio, net_cls, pids) lived in an independent, orthogonal filesystem hierarchy. A process could belong to Group A in the memory controller, but Group B in the blkio controller. This created unresolvable kernel deadlocks: if memory-cgroup A wanted to flush dirty pages to disk, blkio-cgroup B could not attribute I/O costs to the original process, making writeback page cache throttling impossible. cgroups v2 completely abolishes multiple hierarchies in favor of a single unified process tree. Every process belongs to exactly one cgroup node in /sys/fs/cgroup. Controllers are enabled down the hierarchy using cgroup.subtree_control. Processes can only reside in leaf nodes ("no internal process rule"), ensuring unambiguous accounting where writeback I/O, memory allocations, CPU CFS cycles, and eBPF network filters are attributed to the exact same cgroup identity.

Why is userspace systemd-oomd vastly superior to the legacy Linux in-kernel OOM killer?

The legacy in-kernel Out-Of-Memory (OOM) killer only acts as an emergency deadman switch: it triggers strictly when physical RAM and all swap space are 100% exhausted and the kernel allocator experiences a catastrophic page allocation failure. In production systems with heavy page cache workloads, the kernel spends minutes or hours in a violent disk thrashing spiral (repeatedly evicting executable code pages and rereading them from disk) while remaining just barely above 0 free bytes. During this thrash, SSH hangs, HTTP requests timeout, and monitoring alarms fail. systemd-oomd runs in userspace, monitoring PSI metrics (/proc/pressure/memory). When sustained "full" memory pressure exceeds a configured threshold (e.g. 30% for 20 seconds), systemd-oomd identifies the offending cgroup slice and cleanly terminates the entire cgroup unit before the host locks up, ensuring uninterrupted operation for the rest of the node.

How does systemd-oomd determine which cgroup slice or container to kill during pressure events?

systemd-oomd evaluates candidate cgroups within monitored parent slices (such as user.slice, system.slice, or kubepods.slice) using three criteria: (1) ManagedOOMMemoryPressure: Only cgroups explicitly configured with ManagedOOMMemoryPressure=kill are candidates for pressure-based termination; (2) Pressure Threshold Exceedance: The cgroup must have exceeded ManagedOOMMemoryPressureLimit (e.g. 40% full stall for 15 seconds); (3) Swap and Memory Consumption Sorting: systemd-oomd calculates the largest consumers of memory or swap within the offending slice, prioritizing the biggest memory hog and issuing SIGTERM, followed by SIGKILL to the entire cgroup process tree, avoiding partial orphan processes.

Linux PSI (Pressure Stall Information), cgroups v2 & systemd-oomd Architecture Studio

Verified Specification | Standardized Formulas | Instant Precision

Secure & Private (Zero Data Retention) Free Access • No Sign-Up

Linux Kernel 4.20+ / 6.x cgroups v2 Unified Tree Pressure Stall Information (PSI) systemd-oomd Heuristics

Linux PSI, cgroups v2 & systemd-oomd Architecture Studio

Simulate kernel Pressure Stall Information (some vs full stall percentages), configure 4-tier cgroups v2 memory boundaries (memory.min, memory.low, memory.high, memory.max), evaluate proactive systemd-oomd kill decisions, and export tuned production systemd slice definitions.

100% Client-Side Engine

Resource Contention & Workload Injection

Contention Profile Preset

Memory Allocation Contention Level

20%

Disk I/O Saturation (NVMe / SSD Queue Depth)

10%

CPU Overcommit Multiplier

1.5x

Simulated /proc/pressure/ Output

Memory Stalls (avg10)

some 2.4%

Normal allocation speed

Deadlock / Full Thrash

full 0.0%

CPUs fully productive

cgroup v2 Memory Thresholds Configuration

memory.min (Hard Guarantee - Never Reclaimed) In Megabytes (e.g. 2048 MB = 2 GB protected)

memory.low (Soft Guarantee - Proportional Reclaim) Best effort protection during node-wide memory pressure

memory.high (Throttle Boundary - Direct Reclaim Penalty) Allocations throttled with microsecond stalls to slow workload

memory.max (Hard Cap - OOM Killer Trigger) Strict maximum memory allowed before in-kernel OOM invocation

Simulated Container Active Memory Usage

6,144 MB

Kernel Reclaim & Throttling Status

0 MB min: 2G low: 4G high: 8G max: 10G

Architectural Execution Comparison: systemd-oomd vs In-Kernel OOM

Behavior & Metric	Userspace systemd-oomd	Legacy In-Kernel OOM Killer
Detection Trigger	Proactive PSI Stalls (e.g. memory full > 30% for 15s)	100% RAM + Swap Exhaustion & Allocator Fail
Kill Target Scope	Entire cgroup slice / Pod (Clean atomic termination)	Single arbitrary PID (Leaves corrupted parent/child)
System Thrash Duration	Milliseconds (Kills before host stalls)	Minutes to Hours (Severe lockup, SSH unresponsive)
Configuration Granularity	Per-systemd unit (ManagedOOMMemoryPressure)	Per-process oom_score_adj integer (-1000 to 1000)
Graceful Shutdown Option	Sends SIGTERM first, followed by SIGKILL	Instant uncatchable SIGKILL (Data corruption risk)

Linux PSI, cgroups v2 & systemd-oomd Architecture Studio

Resource Contention & Workload Injection

Simulated /proc/pressure/ Output

cgroup v2 Memory Thresholds Configuration

Kernel Reclaim & Throttling Status

Architectural Execution Comparison: systemd-oomd vs In-Kernel OOM

Production Systemd & PSI Blueprints

🔍 Companion Workbenches & Verification Tools

Linux Landlock LSM ABI v4 Network & Path Sandboxing Studio

Distributed Tracing: W3C Baggage, Span Links & Tail Sampling Studio

Linux Kernel Slab Allocator & Free List Hardening Studio | Heap Exploitation Mitigations

Memory-Mapped Files (mmap), Page Cache & Linux Virtual Memory Studio

Why Smart Users Are Switching to This Free Toolkit

The Browser Feature Most People Never Use

Stop Paying for Software You Can Get Free

File Conversion Tricks That Save Hours Every Week

This Free Tool Replaced 5 Paid Apps for Our Team

What Your Browser Can Do Without Any Extensions