This guide explains how to calculate and interpret key Oracle hit ratios—including library cache, shared pool, buffer cache, data buffer, sort memory, and PGA—provides exact SQL statements for each metric, and offers tuning thresholds and actions to improve database performance.
This article explains Redis's LRU eviction mechanism, starting with a brief LRU overview, presenting a Python LRU cache implementation, then detailing Redis's internal LRU clock, object fields, maxmemory policies, and both active and passive eviction processes, highlighting configuration impacts on performance.
The article dissects Redis’s architecture by examining its single‑threaded reactor network model, core data structures and memory‑management tactics, AOF/RDB persistence mechanisms, and master‑slave, Sentinel, and Cluster multi‑node strategies, highlighting how each design choice balances speed, memory usage, and system complexity.
The article quantitatively breaks down HDFS NameNode memory consumption, showing that the Namespace tree and BlocksMap together dominate heap usage (≈53 GB in large clusters), provides detailed per‑object size estimates for NetworkTopology, INode and block structures, and proposes a simple formula to predict total heap requirements and tuning recommendations.
This article analyzes the nano_free crash issue that appeared on iOS 10.0‑10.1.1, explores several attempted fixes such as dylib replacement, source compilation, environment variable tweaks, and hook strategies, and finally proposes a guarded zone solution to reduce crash probability.
This article examines the operational challenges of oversized Redis instances—including slow failover, prolonged slave resynchronization, network‑induced avalanches, and persistence blocking—and offers practical mitigation strategies such as key expiration, data compression, and using high‑performance alternatives like Pika.
This article explains Linux kernel memory management by describing how user‑level malloc allocates virtual memory, how page tables map virtual to physical addresses, and how the hardware‑triggered page‑fault mechanism ultimately provides the needed physical pages.
The article explains MySQL’s DYNAMIC_STRING structure, detailing its fields, how to initialize it with init_dynamic_string, and how functions like dynstr_append_mem, dynstr_trunc, dynstr_realloc, and dynstr_append_os_quoted manage dynamic resizing, truncation, and OS‑quote handling for safe string operations.
This article provides a detailed comparison of Memcached and Redis by examining their service models, event loops, memory allocation strategies, database structures, persistence mechanisms (RDB and AOF), transaction support, and publish‑subscribe features, highlighting the design choices, trade‑offs, and implementation nuances of each key‑value caching system.
This article explains Java's garbage collection mechanisms, covering memory regions, the limitations of reference counting, the root search algorithm, various reference types, the two-phase marking process, and how the method area is reclaimed, illustrated with code examples and diagrams.
This article explains Java's object access mechanisms, detailing how references in the stack point to objects in the heap and type data in the method area, and compares the handle pool approach with direct pointer access, highlighting their respective performance and GC advantages.
This article explains the JVM as Java's operating system, outlines its class loading process, and provides a detailed walkthrough of each runtime memory region—including program counter, stacks, heap, method area, and direct memory—highlighting their purposes and related error conditions.
The article explains how the Linux kernel’s flexible architecture and highly modular design enable massive volunteer contributions, seamless extensibility, and cross‑platform portability by detailing its position in the system, core functions, subsystem interactions, key data structures, and the benefits of its layered, dependency‑driven design.
This article explains Linux’s hardware‑independent three‑tier physical memory model (node, zone, page) and the three‑level virtual memory page‑table hierarchy (PGD, PMD, PTE), including key macros, structure definitions, and the macros used to walk the tables from a virtual address to a physical page.
The G1 Garbage‑First collector is a server‑side, region‑based Java GC designed for multi‑processor, large‑memory systems that concurrently marks objects using SATB, tracks cross‑region references with RSets, and employs a pause‑prediction model to meet user‑specified pause‑time goals while maintaining high throughput.
This guide explains how to interpret Redis INFO output, monitor client connections, memory usage, persistence stats, replication CPU metrics, configure eviction policies, understand the LRU algorithm, and perform performance analysis to keep your Redis instance healthy and efficient.
This article explains the two-stage process by which the Linux kernel parses memory information passed from U‑Boot—first via ATAG tags and then through the boot command line—detailing the relevant code, data structures, and practical methods for modifying memory size on embedded platforms.
This guide demonstrates how to switch Oracle Database 11g between Automatic Shared Memory Management (ASMM) and Automatic Memory Management (AMM), covering environment setup, parameter adjustments, spfile/pfile handling, restart procedures, and troubleshooting, with concrete SQL commands and shared‑memory observations.
The article dissects Hadoop 2.4.1’s HDFS NameNode memory architecture, detailing how the Namespace, BlockManager, NetworkTopology, and LeaseManager consume the heap, exposing scaling problems when metadata reaches hundreds of millions of inodes and blocks, and recommending file merging, block‑size tuning, federation, or external KV stores to mitigate heap pressure.
Android TV, now dominating China’s rapidly expanding smart‑TV market, offers a large shared screen experience and extensive I/O options, while development mirrors Android phone projects using Android Studio and Gradle, with debugging on boxes or tablets, and requires careful handling of limited CPU/memory, background‑process behavior, and wired‑network connectivity.
This article compares Redis and Memcached across data‑type support, memory‑usage efficiency, performance, memory‑management mechanisms, persistence options, and clustering capabilities, highlighting the strengths and trade‑offs of each in‑memory data store.
This article explains the origins and mechanics of Huge Pages, why they are not a universal solution, how they can degrade performance on NUMA architectures, and provides practical testing methods and mitigation strategies for developers and system administrators.
This article explains Linux swap fundamentals, the role of swappiness, kswapd behavior, memory watermarks, and related kernel parameters, providing practical guidance on configuring swap priority, zone reclaim, and other settings to optimize system performance under various workloads.
The article explains how Flink tackles JVM memory challenges by using proactive memory management, a custom serialization framework, cache‑friendly binary operations, and off‑heap memory techniques to reduce GC pressure, avoid OOM, and improve performance in big‑data workloads.
This article explains Linux's memory architecture, covering physical and virtual memory differences between 32‑bit and 64‑bit systems, memory zones, the buddy allocator, page reclamation, and swap handling, providing essential knowledge for performance tuning and system optimization.
This article explains how the Linux free command reports memory usage, clarifies the roles of buffer cache and page cache, demonstrates which cache memory can be reclaimed, and shows practical tests using tmpfs, shared memory, and mmap with code examples.
The article details the author’s experience upgrading a production Spark cluster from version 1.4.1 to 1.6.1, exposing memory‑spill, unified memory, BlockManager deadlock, Yarn‑kill, UI quirks, and Spark‑SQL compatibility issues, and proposes concrete code‑level fixes for each problem.
This article demystifies the Linux free command, explains the distinction between buffer and page caches, shows how various caches are reclaimed—or not—through practical tests with tmpfs, shared memory, and mmap, and provides actionable tips for accurately interpreting memory usage on RHEL 6 systems.
The article explains the design, operation, and performance characteristics of Java's G1 (Garbage‑First) collector, covering its parallelism, generational approach, space‑efficiency, pause‑time predictability, implementation details, execution phases, benchmark results, and practical recommendations for choosing a collector.
This article explains what Objective‑C blocks are, how they function as objects, the three block types, the role of the __block keyword, differences between ARC and MRC, and best practices for managing block lifecycles to avoid memory leaks.
This comprehensive guide explains Oracle's memory‑management evolution, compares manual SGA/PGA sizing with ASMM, AMM and PGA automatic management, details key parameters and hidden settings, shows how to size SGA, PGA and large pages, and offers practical best‑practice recommendations for DBAs.
This article provides concise explanations of core Java concepts including the differences between JVM, JRE and JDK, the roles of PATH and CLASSPATH, variable usage, operators, naming rules, data types, type conversion, Java architecture tiers, cross‑platform nature, signed number representations, functions, overloading, arrays, and memory structure.
This article examines how enabling MySQL 5.6 performance_schema with extremely high max_connections causes excessive virtual memory usage, swap pressure, and eventual out‑of‑memory errors, presents test data, references the related bug, and offers practical recommendations and discussion questions.
Redis provides a configurable maxmemory setting to limit memory usage, and offers several eviction policies—including allkeys‑lru, volatile‑lru, and random strategies—implemented via an approximate LRU algorithm whose behavior can be tuned with maxmemory‑samples, allowing administrators to balance performance and memory reclamation.
This article explains Node.js memory architecture, how the V8 engine allocates and frees memory across code, stack, and heap, demonstrates using process.memoryUsage() to monitor RSS, heapTotal and heapUsed, describes V8’s Scavenge and Mark‑Sweep garbage collectors, and provides practical techniques for detecting and debugging memory leaks with heap snapshots and profiling tools.
This article explores PHP's underlying architecture, covering its design philosophy, four‑layer system (Zend engine, extensions, SAPI, and applications), execution flow with opcodes, core data structures like HashTable, and the internal representation of variables via zval, providing deep insight for backend developers.
The article explains why modern web systems face ever‑increasing concurrent connections, analyzes how front‑end techniques and server‑side configurations such as Apache MPM modes, Nginx, sendfile, and epoll can reduce memory and CPU consumption, and offers practical recommendations for efficient backend architecture.
This article explains how Linux's Page Frame Reclaim Algorithm categorizes pages, uses kswapd and pdflush threads, and relies on vmstat parameters to manage virtual memory, illustrating the process with examples and key configuration settings.
This article demystifies JavaScript closures by explaining when they are created, how the scope chain and lexical environments operate, why closures persist in memory, and how nested functions and the garbage collector interact, illustrated with clear code examples and diagrams.
This article explains C#'s managed and unmanaged resource handling, memory regions, garbage‑collection algorithms, generational GC, finalizers, the IDisposable pattern, value vs. reference types, and practical methods for discovering and pinpointing memory leaks in Windows Phone applications.
This article explains why modern web systems face exploding concurrent connections, how richer page interactions and higher browser limits increase server load, and presents front‑end caching, request merging, Apache/Nginx memory‑saving modes, sendfile, and epoll techniques to reduce both memory and CPU consumption.
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.
