Memory in Practice: Architecture, Allocation Strategies, and Production-Grade Memory Engineering by Samir Chekkal
English | August 10, 2026 | ASIN: B0HDP3N2SM | 177 pages | EPUB | 10.22 Mb
The pod was killed at 03:14. The heap was half empty. Both facts were true.
Memory is the last resource most engineers learn to reason about, and the first one that takes production down. A JVM sized to 4 GB gets OOMKilled inside a 6 GB container. A Go service leaks steadily for nine days and then falls over. A Python worker's RSS never comes back down after the nightly batch. In every one of these the numbers were visible the whole time - nobody knew which number to read.
Memory in Practice is the missing layer between "add more RAM" and a real diagnosis. It works from the hardware upward: the memory hierarchy, virtual memory and page tables, what the allocator does between your malloc and the kernel, what the garbage collector is actually trading away, and why the number your runtime reports almost never matches the number your orchestrator enforces.
What you will learn to design, measure, and defend The hierarchy that governs everything. Registers, L1/L2/L3, DRAM, and disk - and why a cache-hostile data layout costs more than a bad algorithm.
Virtual memory for engineers, not students. Page tables, the MMU, demand paging, copy-on-write, and the page cache - explained through the behaviour they cause in production.
Allocator internals. Size classes, arenas, thread caches, and fragmentation. Why glibc malloc, jemalloc, tcmalloc, and mimalloc behave differently under the same load, and how to tell which one you want.
Garbage collection without folklore. Generational, concurrent, and region-based collectors; the throughput / latency / footprint triangle; and why most "GC tuning" is actually allocation-rate tuning.
The metrics that mean something. RSS, PSS, USS, working set, committed versus reserved, heap versus native. What each one omits, and which one gets you killed by the kernel.
Containers and Kubernetes. cgroup v2 limits, requests versus limits, the OOM killer's arithmetic, why the JVM and the runtime disagree with the cgroup, and how to size a limit you can defend.
Leak hunting that converges. Heap dumps, allocation profiles, dominator trees, native leaks that never show in the heap, and the difference between a leak, a cache, and a slow-moving working set.
Advanced layout and off-heap. Data-oriented design, arena and slab allocation, memory-mapped files, zero-copy paths, NUMA locality, and huge pages.
Cost engineering at fleet scale. Turning memory headroom into a measured budget instead of a superstition, and right-sizing thousands of workloads without a wave of incidents.
Links are Interchangeable - Single Extraction
