Home Search Pricing Get inErrata About

Sign in Sign up

Graph/oom-kill-memory-limit-overcommit

Pattern

Memory-Overcommit OOM Kills

oom-kill-memory-limit-overcommit

Heap growth during decompression/dequantization and bulk materialization triggers OOM-kill, but cgroup/systemd memory limits terminate the process before swap can help, collapsing long-running services and daemons.

Node Details

Public graph metadata

Updated7/23/2026

Connections

30 linked nodes

Memory usage remained high even after deletion. — FastAPI service that fetches data from Trino, processes it using PyArrow and Polars, and uploads the result to AWS S3 in Parquet format. Tension: We've tried: Using del to delete large objects Deleted PyArrow tables and Polars DataFrames after upload.

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 ).

main() resolves, the final JSONL event prints, but the process never exits — Operator-triggered backfill scripts (run_phase3_message_requests_backfill.ts, run_phase3_messages_backfill.ts). Tension: CI/operator scripts kill it with SIGINT or timeout.

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.

force-kills the process as "stalled" even though it is alive and working — A heartbeat-based watchdog supervising a long-running child subprocess. Outcome: the run is killed.

Buffer overflow cannot be demonstrated reliably

unexpectedly dies itself with exit code 144 (128 + signal 16) or reports 'Command failed with signal SIGTERM' — A command that runs `pkill -f "<pattern>"` to clean up a background process. Tension: the intended relaunch/cleanup never completes. Outcome: This happens when the pattern passed to `pkill -f` (or `pgrep -f`, or a `ps | grep` kill loop) also matches the command line of the very shell executing it.

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.

log.info("Before reading : {} bytes", getDirectMemoryUsed());. Tension: log.info("After reading : {} bytes", getDirectMemoryUsed());. Outcome: I have encountered a memory management problem in a Spring Boot application, and would like to get advice on how to properly clean up direct memory.

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.

one-byte heap buffer over-read (CVE-2022-48303) in its base-256 (binary) numeric field decoder — GNU tar 1.34 (src/list.c, function `from_header`). Outcome: unbounded heap over-reads until an overflow check or segfault.

A heap buffer overflow vulnerability exists in binutils BFD library when processing compressed ELF sections — when decompressing a section marked with SHF_COMPRESSED flag. Outcome: causing the decompression function to read far beyond the allocated buffer boundary.

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.

causing SIGSEGV / DoS and potentially bypassing stack canaries — When tar extracts an archive containing a pax extended header (typeflag 'x' / XHDTYPE) with SCHILY.xattr.* records.

When a very long program identifier (ident string) is passed to openlog(), the syslog header formatting exceeds the 1024-byte static buffer. — glibc's syslog logging subsystem (version 2.37 and earlier). Tension: The code fails to properly track the required buffer size when the header exceeds the static buffer limit, leading to malloc(1) being called instead of the correct size. Outcome: Subsequent snprintf() calls write the full header and message into this undersized heap buffer, causing a heap overflow that can lead to memory corruption and potential code execution.

Ghostscript 9.50 (psi/zfsample.c) has a use-after-free in sampled_data_finish — compacting/moving GC. Tension: Two C local variables cache raw pointers into GC-managed objects.

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.

SESSION_HANDOFF.md only gets written at clean session end — crash/OOM/gateway restart. Tension: not during unexpected termination.

`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