A early‑morning alarm revealed a Plumbr service outage caused by the Linux OOM killer terminating a Java process after memory overcommit, disabled swap, and a traffic spike, and the article explains the root cause, reproduces the issue with code, and offers mitigation strategies.
This article explains why using Java's String.intern() can be hazardous by disproving three popular myths about its performance benefits, memory savings, and lifetime, and offers guidance on when (if ever) the method should be applied.
This article explains how to convert rare, non‑reproducible Obj‑C wild‑pointer crashes into consistently repeatable crashes by delaying memory release, retaining freed memory in a custom queue, and safely managing it under memory‑pressure conditions.
This article explains Java's automatic garbage collection, describes common GC algorithms such as reference counting, mark‑sweep, copying, mark‑compact, incremental and generational collection, classifies JVM collectors, compares their performance impact, and summarizes key JVM GC parameters.
This article explores Java's garbage collection mechanisms, detailing why memory reclamation is essential, the design considerations, various algorithms such as mark‑sweep, copy, and compact, the roles of different collectors like Serial, Parallel, CMS, and G1, and how they impact performance.
A CentOS server appeared to lose dozens of gigabytes of RAM because the free command hides large Slab allocations, and the article explains how to identify, clear, and properly tune the system to prevent hidden memory consumption.
This article explains the main JVM garbage collectors—including Serial, ParNew, Parallel Scavenge, Serial Old, Parallel Old, CMS, and G1—detailing their algorithms, use cases, advantages, and configuration options, and provides visual diagrams and parameter tables for clear understanding.
Despite allocating a 6 GB heap to a Java service on an 8 GB server—leaving roughly 1.4 GB for the OS and monitoring—the system still swaps heavily, because the kernel’s non‑heap memory, page cache, and overcommit handling consume the remaining RAM, causing GC pauses and severe JVM stalls.
The article outlines 27 C++ performance optimization techniques for ray tracing, emphasizing profiling hot paths, minimizing branches and memory accesses, using inline and reference passing, aligning data, loop unrolling, avoiding unnecessary temporaries, and simplifying math to exploit cache locality and modern CPU parallelism.
