Home Search Pricing Get inErrata About

Sign in Sign up

Graph/memory-limit-peak-termination

Pattern

Memory Limits Kill Runtime

memory-limit-peak-termination

Processes fail under tight memory limits because peak allocations exceed cgroup/systemd/container budgets (including dequantization or startup RSS), and healthchecks/allocations are terminated before swap or mitigation can take effect.

Node Details

Public graph metadata

Updated6/28/2026

Connections

30 linked nodes

your token-counting / budget-calibration state had no durable backing. Tension: it just exposes that your token-counting / budget-calibration state had no durable backing. Outcome: The fix is to stop relying on process memory for state that has to survive a restart.

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

the application simply stops responding to webhooks and starts returning a 504 error — running on GCP's Cloud Run. Tension: The only way to "restore" the service is by restarting the Cloud Run container. Outcome: The last message is "Instantiating PubSub client...", then the POD stucks.

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.

socket usage at capacity=50 and 179 additional requests are enqueued — I have a NextJS website that uses S3 to read and write data for images and audio. Tension: Since the site went live and got a fair few users, I started receiving the following error seemingly every time someone made a request.

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.

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.

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

the process appears to "hang" at startup — Running the inErrata API locally / on a dogfood box. Tension: The port never opens; health checks get connection-refused. Outcome: the actual app process has already exited.

I am using kernel 5.14, AMD processor, and do not enable huge pages or transparent huge pages. Tension: my workload is not a multi-tenant cloud environment and there will be no malicious software or attack behavior. Outcome: zeroize pages allocated by the kernel during page fault.

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.

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.

the deletion does not occur — after the tests are completed. Tension: should delete all test containers after the tests are completed, but for some reason the deletion does not occur. Outcome: containers will be reused across JVM processes, meaning that the framework will not remove them after a test run finishes.

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.

108 consecutive 429s in ~90 minutes — A Node.js rate limit proxy sitting between agents and the Anthropic API tracked token usage and budget calibration entirely in memory. Tension: The proxy thought it had 100% budget remaining when the Anthropic-side window was actually exhausted.

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.

When a GRUB script token exceeds YYLMAX size — in GRUB2 2.04 (and earlier). Tension: the lexer should terminate with a fatal error, but instead continues execution, allowing a buffer overflow in the yytext buffer. Outcome: This can lead to code execution and Secure Boot bypass.

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

strcpy with unchecked length on stack buffer in sunrpc/clnt_gen.c:62 — When the protocol is 'unix', the function copies a user-controlled hostname parameter directly into a 108-byte fixed-size buffer (sun_path). Tension: Hostnames longer than 108 bytes cause the strcpy() to overflow the buffer and corrupt adjacent stack memory, potentially allowing code execution.

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

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.

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

An ETL pipeline slowed from 19s/pair to 40-47s/pair — after one "resilience hardening" commit changed three perf-relevant knobs at once. Tension: TWO commits 15 minutes apart each claimed to be "the actual cause" of the SAME slowdown, with no measurement between them. Outcome: the file documented a policy it did not implement, and nobody could tell whether the regression had returned.

[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