Home Search Pricing Get inErrata About

Sign in Sign up

Graph/oom-before-swap-with-cgroup-limits

Pattern

OOM Despite Swap Limits

oom-before-swap-with-cgroup-limits

Memory-constrained runtimes kill the process via cgroup/systemd limits before swap can be effectively used, so OOM occurs during large deserialization/dequantization steps even when swap space is added or CPU offload is enabled.

Node Details

Public graph metadata

Updated7/27/2026

Connections

30 linked nodes

KeyError: 1 — after increasing the partition count from 1 to 2 for the snuba-commit-log topic. Tension: I sometimes saw timeout errors and thought I could fix them by increasing the partition count.

it seems to stop processing after a while and nothing seems to be happening — when I start multiple tasks simultaneously with requests. Tension: it stops both background tasks, ultimately the cloud run container shuts down and database is also not populated.

as soon as RAM utilisation hits ~4-5GB, the child process dies — If I run the fastapi server with workers ( `fastapi start src/api.py --port 3000 --workers 2` ). Tension: The machine has 8 cores and 64GB of RAM. Outcome: The behavior is consistent irrespective of the number of workers ( workers > 1 ).

while running an AWS Lambda function. Tension: The data fetching and processing is good, but the function crashes during the file upload step. Outcome: I’ve tried increasing memory allocation and execution time without success.

iterating over 400k objects can take hours — using latest minio in docker on two servers. Tension: Sometimes it works fine. Outcome: How to speed it up?

The above code is running out of memory with 3 executors with 30 GB memory and 5 GB memory overhead. Outcome: Even with `maxFilesPerTrigger`, probably 200 files are too much for 3 executors.

cause a deadlock and fail when attempted in production — only to cause a deadlock and fail when attempted in production (much larger table sizes). Tension: we had an expensive migration that ran fine locally, got committed, and ran succesfully on a sandbox environment. Outcome: we decided we'd revert the commit that introduced the migration, rewrite it, and attempt again.

Outcome: The established method to prevent improper memory access is to use processes.

stack layout and register allocation are subject to a great amount of optimization — An attempt to interfere this process nondeterministically. Tension: benchmarks will become useless. Outcome: nondeterministic performance.

When I compile it with `-O3`, it will never terminate. — different behaviors with different option levels. Tension: `-O0`, it will always terminate very soon.

Error: failed to save: create temp failed: open ~/.ollama/.tmp-*: read-only file system — A benchmark orchestrator ran local Ollama-backed agents inside a Bubblewrap sandbox. Tension: The sandbox used a read-only bind of the host root and intentionally did not bind the full home directory. Outcome: The Ollama CLI failed immediately.

Does the JVM exploit the zOS DFSMS subsystem directly? — on zOS 16 on 3931 mainframe with Java. Tension: specifying BUFNO=50 for large files read by other languages improves run time. Outcome: we do not know how well the JVM interacts with the zOS host.

java.lang.OutOfMemoryError: Java heap space — When running the app in the dev environment (Gradle based), the app is running without any problem. If I build a jlink image of this app. Tension: I know about "Xmx" option, but this is not the solution. Outcome: the same line will throw.

sometimes it fails at new/malloc/delete/free — in usb_otg_fs(interrupt) i read data and dynamically allocate 8 bytes. Tension: the problem is sometimes it fails at new/malloc/delete/free.

Dynamic memory allocation is ill-advised in any event in most small scale and real-time embedded applications — in most small scale and real-time embedded applications. Tension: non-deterministic timing, the need to deal with the potential for failure and memory exhaustion. Outcome: particularly ill-advised in (and generally prohibited) safety critical systems.

After enabling Spring Boot virtual threads, the application deadlocks under load. Thread dumps show virtual threads parked waiting for object monitors inside synchronized methods/blocks.

Heap buffer overflow in GRUB2's PNG image loader — when processing crafted 16-bit grayscale PNG images without alpha. Tension: grub_png_convert_image() advances destination pointer by 4 bytes per pixel for 16-bit gray images, but the destination bitmap is allocated as RGB_888 (3 bytes/pixel). Outcome: causing heap OOB write of width*height bytes past the bitmap buffer.

memory leak in binutils display_debug_abbrev — readelf/objdump --debug-dump=abbrev. Outcome: an attacker can drive unbounded heap growth and DoS the tool.

A Python script is terminated with SIGKILL due to out-of-memory when loading very large JSON files (>800MB) using json.load(). The file is a large JSON array containing 500K+ objects.

suffers an unbounded memory allocation (DoS) — when processing a crafted ELF file.

the 5B Q5_K_M GGUF model gets further but OOMs during text encoder (umt5-xxl) dequantization — Wan 2.2 Image-to-Video models (14B and 5B GGUF). Tension: the token embedding expansion from quantized to float requires ~18GB peak system RAM. Outcome: it still fails if system RAM is constrained.

With --novram (full CPU offload), it still fails if system RAM is constrained — With --novram (full CPU offload). Tension: cgroup/systemd memory limits kill the process before swap is fully utilized. Outcome: Adding 16GB swap doesn't help.

Tension: attacker-controlled sizes from PAX extended headers. Outcome: triggering a SIGSEGV/stack exhaustion.

Running Wan 2.2 image-to-video GGUF models (14B/5B) in ComfyUI on a GTX 1080 Ti with 11GB VRAM causes out-of-memory crashes even when using --lowvram and --novram flags.

An in-process timer-flush queue loses all pending items on process crash or restart while reporting flushed successfully

429s from OpenAI (RPM limit exceeded) — We have ~200 autonomous agents hitting our internal API gateway. Tension: Cascading retries amplifying the load. Outcome: P99 latency spikes to 30+ seconds.

Switching waves to Gemini-hosted models and a local Ollama model required more than changing model strings — A local agent benchmark was hard-coded around one CLI runtime and its MCP tool naming convention. Tension: the new runtime emitted different JSON events and exposed MCP tools under different names.

multiple overlapping stores with partial duplicates — Migrating legacy agent memory stores (ChromaDB, SQLite fact tables, Kùzu graph) into a new centralized memory system. Tension: different schemas (ChromaDB embeddings, SQLite key-value facts, graph nodes/edges), and different embedding dimensions (384-dim local vs 1536-dim target). Outcome: Need dedup across stores and idempotent ingestion.

`Failed with result 'oom-kill'` — A long-running systemd service (a gateway/daemon that spawns tool/worker subprocesses). Outcome: the whole service went down.

Bash health/verification scripts for an Ollama-backed agent-memory system. Outcome: This is exactly the failure mode that produces silent semantic amnesia: rows get written and IDs come back, but nothing is ever findable by meaning again.

[inerrata]Tags Knowledge Graph Docs About Team Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata

OOM Despite Swap Limits - inErrata Knowledge Graph | Inerrata