How the systemd calculator works

01 What the two settings do

• MemoryHigh is the throttling limit: above it the service's processes are heavily slowed down and memory is taken away aggressively. systemd calls it the main mechanism to control a unit's memory. systemd docs
• MemoryMax is the absolute limit: if usage can't be kept under it, the OOM killer runs inside the unit. systemd recommends it as the last line of defense. systemd docs

They set the kernel's memory.high and memory.max. The kernel's own documentation calls memory.max the main way to limit a cgroup's memory; systemd's advice is the one the calculator follows, because it's about services. Kernel docs

There's no scheduler, so nothing reserves memory for the service: the average-based value is shown as expected usage, for reference only.

02 MemoryHigh, MemoryMax and expected usage

expected usage = average × (1 + request margin)                     rounded up to a whole M
MemoryHigh     = max(peak × (1 + limit margin), expected usage)     rounded up to a whole M
MemoryMax      = 1.25 × MemoryHigh                                   rounded up to a whole M

The margins come from the sensitivity, workload type and environment you choose; the sizing model explains them, and they are assumptions too. systemd reads the M suffix with base 1024, so M is MiB. systemd docs

• MemoryHigh sits just above the observed peak, so normal peaks run unthrottled and throttling only starts when usage grows past anything seen so far, typically a leak. It never goes below expected usage, so a steady service isn't throttled at its normal level. Assumption
• MemoryMax is 25% above MemoryHigh, so MemoryHigh sits 20% below it. The gap is warning time: a leak slows the service down before the kernel kills it. Neither systemd nor the cgroup v2 memory controller's own documentation gives a ratio: both treat the high limit as the main control and the max as a final safety net, which by default isn't set at all. cgroup2 docs 1.25× is ours, at the low end of what guides outside the official documentation commonly suggest: the high limit 20–30% below the max (1.25–1.43×). Assumption

Worked example

Average 295 MiB, peak 390 MiB, generic workload, medium sensitivity, production:

A steady cache, averaging 1000 MiB with a 1020 MiB peak, where expected usage decides MemoryHigh:

03 What the calculator writes

[Service]
MemoryHigh=507M
MemoryMax=634M

• Saved as /etc/systemd/system/<service>.service.d/override.conf, it's a drop-in: systemd reads every .conf file in the unit's .service.d/ directory on top of the unit file. systemd docs Then systemctl daemon-reload && systemctl restart <service>.
• Or, without a restart: systemctl set-property <service>.service MemoryHigh=507M MemoryMax=634M changes resource settings at runtime and keeps them for future boots. systemd docs

04 cgroup v2 only

Both settings control the memory controller of the unified hierarchy, cgroup v2. systemd docs Since systemd 258, cgroup v1 isn't supported at all. On older hosts still running it, the only setting is MemoryLimit=, deprecated since systemd 252. systemd NEWS

05 Every warning, and why

06 What to paste

container_memory_working_set_bytes{id="/system.slice/myapp.service"}

• With cAdvisor on the host, its id label is the cgroup path, so a service is /system.slice/<name>.service. cAdvisor source
• Without Prometheus, sample systemctl show -P MemoryCurrent myapp.service every minute and paste the bytes. MemoryCurrent reports the unit's memory.current, the cgroup's total usage, which counts page cache too; so it reads a little higher than the working set. Kernel docs systemd's documentation lists the property without describing it. Assumption

The Docker Compose guide reads the same cAdvisor working-set metric, filtered by container name instead of cgroup path.

07 All assumptions in one place

Besides the margins of the shared sizing model:

Our default: a value we chose. Our reading: how we read documentation that isn't explicit. About your setup: something we take for granted about your data or cluster.

Values you can change

The calculator’s Advanced: margins and defaults section, closed by default, lets you replace these values when your setup differs. Each field’s “?” says how it moves the result; a value outside the range is used at its nearest end, and “Reset to defaults” puts them all back.

08 References

• systemd.resource-control (source) — MemoryHigh=, MemoryMax=, units, and the deprecated MemoryLimit=.
• systemd NEWS — cgroup v1 removed in systemd 258.
• systemd.unit — drop-in directories.
• systemctl — set-property and show -P.
• cgroup2 memory controller (Meta, the controller's authors) — memory.high as the main control, memory.max as the safety net.
• Control Group v2 (kernel) — memory.current, memory.high, memory.max.
• cAdvisor source — the id label.

← Back to the systemd calculator