This article documents a hands‑on experiment that allocates a 50 GB Redis instance on a 64 GB dual‑node machine, explores NUMA behavior, demonstrates how memory affinity can trigger swap, and concludes with practical recommendations for Redis memory sizing and NUMA binding.
An extensive guide walks through Linux’s core components—kernel, memory and process management, VFS, device drivers, networking, shells, filesystem hierarchy, partitioning, mounting, and link types—detailing their structures, key commands, and practical examples for system administrators and developers.
This comprehensive guide explains the core components of a Linux system—including the kernel, memory management, process scheduling, device drivers, networking, shells, file‑system types, VFS architecture, mounting procedures, and link handling—providing clear examples, commands, and diagrams for each topic.
This article provides a comprehensive overview of the G1 (Garbage First) collector, covering its region-based memory layout, cross‑generation reference handling, SATB write barriers, various GC phases (Young, Mixed, Full), and how to interpret detailed G1 GC logs for performance tuning.
This article explains how Java handles String literals and concatenation, detailing the roles of the String constant pool, the effects of the '+' operator invoking StringBuilder.append, the placement of resulting strings in the heap versus the pool, and demonstrates these concepts through bytecode analysis and code examples.
This article explains how Redis implements its own string type using Simple Dynamic Strings (SDS), details the internal structure and dynamic expansion mechanism, and highlights the performance benefits such as O(1) length retrieval, buffer‑overflow protection, and reduced memory allocation overhead.
The article dissects Glide’s lifecycle management by tracing how Glide.with creates a singleton RequestManager via RequestManagerRetriever, caches headless RequestManagerFragments, forwards Activity/Fragment callbacks through ActivityFragmentLifecycle to pause, resume, or clear image requests, monitors network changes with a ConnectivityMonitor, and responds to memory pressure via component callbacks, thereby integrating Android component lifecycles, connectivity, and memory management into its image‑loading engine.
This article explains the rarely understood ES6 features WeakMap and WeakSet, compares them to Java’s weak references, and demonstrates practical Node.js and front‑end use cases such as memory‑safe context storage, result caching, and tracking unhandled promise rejections.
This article explains how Flink manages memory through its MemorySegment abstraction, the implementations of HeapMemorySegment and HybridMemorySegment, the role of ByteBuffer, NetworkBufferPool and LocalBufferPool, and details the end‑to‑end data flow from RecordWriter to Netty transport, including key code snippets.
The article explains how Java determines whether an object is alive using two main garbage‑collection algorithms—Reference Counting and Reachability Analysis—detailing their mechanisms, limitations such as circular references, the role of GC Roots, finalization, and method‑area reclamation, with illustrative code examples.
This article explains iOS property attribute categories, the memory‑related modifiers assign, weak, strong and copy, clarifies why assign can cause dangling pointers while weak does not, and describes typical retain‑cycle cases caused by blocks, NSTimer and delegate misuse along with practical solutions.
This article breaks down iOS's memory layout—including stack, heap, static, data, and text sections—and examines three key management techniques: Tagged Pointers, non‑pointer isa, and SideTables, detailing their implementation, benefits, and underlying data structures.
This article explains the fundamentals of JVM garbage collection, its generational algorithms and associated performance issues, and then details Apache Flink's memory management architecture, including MemorySegment, off‑heap buffers, serialization mechanisms, and type information for efficient big‑data processing.
This article explains the JVM memory layout, how objects are reclaimed through reference counting and GC roots, compares major garbage‑collection algorithms, describes when objects are promoted to the old generation, and provides practical tuning tips to minimize Full GC pauses.
This article explains how to set Redis's maximum memory usage via configuration files or runtime commands, details the various eviction strategies including noeviction, LRU, random, and LFU, and provides Java code for a simple LRU cache implementation.
This article explains the Linux mmap system call, covering virtual address space fundamentals, how mmap interacts with the page cache and inode structures, typical use‑cases such as shared memory and anonymous mappings, code examples, and special considerations like alignment, copy‑on‑write and memory swapping.
This article explains the JVM memory model, how the JVM decides whether an object is alive using reference counting and reachability analysis, and describes the main garbage‑collection algorithms—including mark‑sweep, mark‑compact, copying, and generational collection—along with their advantages and drawbacks.
This article explains how Redis removes expired keys using periodic and lazy deletion, describes the slave expiration handling, details the asynchronous memory reclamation commands like UNLINK and FLUSHALL ASYNC, and outlines the various maxmemory eviction policies including LRU, LFU, and their implementations.
This article explains Java garbage collection fundamentals, detailing JVM memory layout, key -X and -XX parameters, the mechanisms of object survival, and the main GC algorithms—Mark‑Sweep, Copying, Mark‑Compact, and generational collection—providing clear diagrams and interview‑ready insights.
This article explains the Java Virtual Machine’s memory layout, covering the five runtime regions—heap, method area, JVM stacks, native method stacks, and program counter—along with their purposes, thread‑visibility, garbage‑collection behavior, and common pitfalls such as OutOfMemoryError and StackOverflowError.
This article examines whether PHP's unset() truly releases memory, debunks common myths, explains the distinction between language constructs and functions, explores memory_get_usage, and demonstrates through code examples how Zend Memory Manager handles variable cleanup under different scenarios.
This article explains how the JVM memory layout evolved from Java 7 to Java 8, detailing the shift from the permanent generation to Metaspace, the underlying spec versus HotSpot implementation, and the key JVM flags that control class metadata allocation.
This article provides a comprehensive introduction to the Java Virtual Machine’s memory architecture, detailing the five runtime areas—Program Counter, JVM Stack, Native Method Stack, Heap, and Method Area—their thread scope, memory allocation, garbage‑collection behavior, and common errors such as OutOfMemoryError and StackOverflowError.
This article investigates whether to allocate new memory for each incoming message or to reuse memory from a pool, analyzing the impact on throughput and latency in batch and soft‑real‑time applications, and presenting extensive benchmark results for various garbage collectors, JVM options, and native C++ implementations.
This article provides a detailed analysis of DBLE's memory management module, explaining its structure, configuration parameters, allocation and recycling logic, and includes annotated source code snippets for classes such as DirectByteBufferPool and ByteBufferPage, illustrating how off‑heap and on‑heap memory are handled.
This article walks you through applying object‑oriented concepts in C by implementing the State design pattern, covering class simulation with structs, inheritance via macros, lifecycle management, polymorphism, and a complete client example that demonstrates state transitions for a water model.
This article explains why a Java process consumes far more virtual memory than the configured heap size by detailing JVM subsystems, off‑heap allocations, native libraries, thread stacks, and other factors that contribute to overall memory usage.
This article explains Go's garbage collection mechanism, describing its Mark‑Sweep model, the three collection phases, latency implications, and practical tips for reducing pause times through memory‑pressure reduction and runtime debugging tools.
This article explains the two ways to create Java strings, demonstrates how string literals are shared in the method area, shows the effect of the intern() method at runtime, and discusses why the String class is final, immutable, and thread‑safe.
This article explores Linux kernel memory management, detailing process address space allocation, the behavior of the OOM killer, various memory mapping types (shared, private, anonymous), cache usage, manual and automatic memory reclamation, and related kernel parameters, providing practical insights and examples.
This article provides a comprehensive overview of the JVM runtime memory areas, explains how the JVM determines garbage objects, reviews major GC algorithms and collectors—including the latest ZGC—and offers practical code examples and command‑line instructions for reproducing various OutOfMemoryError scenarios.
Java’s garbage collection, a critical yet often overlooked feature, encompasses various algorithms such as reference counting, reachability analysis, mark‑sweep, copying, and generational collection, each with distinct mechanisms, trade‑offs, and impacts on memory regions like Eden, Survivor, and Old spaces.
This article explains Apache Spark's memory architecture, covering the shift from static to unified memory management, the roles of on‑heap and off‑heap memory, configurable parameters, dynamic memory sharing between execution and storage, and the legacy mode introduced in Spark 1.6.
From Bill Gates’s 640 KB claim to today’s multi‑gigabyte machines, this article explains how loaders map executable files, the evolution from segmentation to swapping and paging, and why virtual memory lets programs run with far less physical RAM despite performance trade‑offs.
This article lists the most frequent Java OutOfMemoryError cases—including Java heap space, GC overhead limit exceeded, PermGen/Metaspace, native thread creation failures, array size limits, and direct buffer memory—explains their root causes, and provides practical troubleshooting steps and JVM tuning parameters to resolve them.
This comprehensive guide explores Node.js Buffer fundamentals, binary data handling, stream integration, memory allocation mechanisms, practical usage scenarios, and performance benchmarks, providing developers with the knowledge to efficiently manage binary streams and boost application speed.
This tutorial explains why Java applications often exceed their -Xmx limits, enumerates the main sources of native memory consumption in the JVM, and shows how to monitor and analyze these allocations using Native Memory Tracking (NMT) commands and flags.
This article explains how the Linux kernel manages memory reclamation, the role of kswapd, the distinction between file and anonymous pages, the impact of swap and the swappiness parameter, and provides practical guidance for tuning swap usage in production systems.
Redis 5.0 builds on 4.x with new Stream data type, enhanced memory management, and several command improvements—including XADD, XGROUP, XREADGROUP, XACK, and ZPOPMIN/ZPOPMAX—while also adding LFU/LRU support in RDB snapshots and client‑side enhancements for easier cluster management.
This article explains Java garbage collection in depth, covering its definition, historical origins, reference‑counting and reachability algorithms, GC roots, memory regions such as Eden, Survivor and Old, and the main collection strategies like Mark‑Sweep, Copying, Mark‑Compact and Generational collection.
This article explains the design principles, region-based architecture, object allocation strategies, Young and Mixed G1 GC phases, concurrent marking, three‑color marking, and practical tuning parameters for the G1 garbage collector in Java, illustrating concepts with code snippets and diagrams.
This article explains Spark's executor memory architecture, covering on‑heap and off‑heap memory planning, static and unified memory managers, storage and execution memory allocation, RDD persistence, eviction policies, and shuffle memory usage, providing practical guidance for performance tuning.
This article explains Java's runtime memory regions, including the program counter, stacks, heap, method area, constant pool, and direct memory, and details the HotSpot object creation process, memory layout, access mechanisms, as well as String and wrapper class behaviors, providing essential knowledge for Java interview preparation.
After a 2018 Flutter upgrade caused a mysterious “Ghost Crash” in Xianyu’s app, engineers traced an over‑released NSMutableArray in the accessibility bridge, fixed an illegal dealloc call, added proper checks for iOS Speak Screen, and eliminated the crash through a rapid gray‑scale rollout.
This article explains the overall architecture of the JVM, details each component of its runtime data area—including program counter, stacks, heap, and method area—and discusses related concepts such as the runtime constant pool and direct memory, providing a comprehensive overview for developers.
This article continues the deep dive into Apache Spark memory management, explaining storage memory handling—including RDD persistence, caching, eviction, and disk spilling—as well as execution memory allocation for multi-tasking and shuffle operations, and detailing Spark’s internal structures such as BlockManager, StorageLevel, and Tungsten page management.
This article explains Spark's memory management architecture, covering on‑heap and off‑heap memory planning, the MemoryManager interface, static versus unified memory allocation strategies, and how dynamic borrowing improves resource utilization for Spark executors.
This article explains how Xcode’s static analysis feature can automatically identify common iOS development problems—including localization warnings, logical errors, memory leaks, dead stores, and syntax mistakes—by analyzing code without execution, and shows how to resolve each type of issue.
The article explains Go slices as three‑field descriptors pointing to an underlying array, details creation methods, shows the low‑level runtime representation and assembly for make, describes how append triggers growslice with capacity‑doubling or ~25 % growth and alignment, and clarifies sharing, nil slices, and passing semantics.
This comprehensive guide explains the JVM memory areas, the fundamentals of garbage collection, generational heap management, various GC algorithms, and practical tuning parameters for Java applications.
This article explains how Xcode’s static analysis feature can automatically identify text localization problems, logic errors, memory management concerns, dead‑store data issues, and syntax mistakes in iOS projects, and provides step‑by‑step instructions and code examples for fixing each type of warning.
This guide presents 45 practical Java performance optimization techniques—ranging from proper use of singletons and final modifiers to efficient collection handling and avoiding costly operations—helping developers write faster, more memory‑efficient code.
Matrix for iOS/macOS is an open‑source performance probing tool from the WeChat team that monitors crashes, jank, and memory issues on iOS and macOS, offering plugins for detailed stack capture and out‑of‑memory reporting, with future plans for power‑consumption tracking and cloud integration.
This article provides an in‑depth overview of why Redis is used, its drawbacks, the reasons behind its single‑threaded speed, data types and use‑cases, expiration policies, memory eviction strategies, consistency challenges with databases, and practical solutions for cache penetration, cache avalanche, and concurrent key competition.
This article explores Linux kernel memory management in depth, covering process address space layout, allocation mechanisms, OOM killer behavior, the whereabouts of allocated memory, and both manual and automatic memory reclamation techniques.
During the migration of a billion‑record Java service from physical servers to a private‑cloud Docker environment, a series of JVM GC tuning steps—including adaptive young generation sizing, larger young generation, reduced concurrent GC threads, and phantom‑reference cleanup—significantly reduced stop‑the‑world pauses and restored service performance.
This article explains Redis's memory model—including memory statistics, allocation, internal data structures like redisObject and SDS, object type encodings, and practical techniques for estimating usage, reducing fragmentation, and optimizing memory consumption—providing developers with actionable insights for high‑performance backend systems.
This article explains Java's enduring popularity by highlighting its write‑once‑run‑anywhere philosophy, built‑in multithreading, automatic memory management, scalability, cross‑platform capabilities, security features, and its strong presence in enterprise, IoT, mobile, and big‑data applications.
This article explains the evolution of JVM garbage collectors from Serial to G1, details the different collector types, describes G1's memory model and collection phases, and outlines scenarios where G1 provides low‑latency, high‑throughput garbage collection for large Java applications.
This article provides a comprehensive overview of Redis, covering its core concepts, common use cases, and detailed explanations of internal objects such as redisObject, dictEntry, SDS, and the underlying data structures for String, List, Hash, Set, and ZSet, including code snippets and performance characteristics.
The article explains Java’s sun.misc.Unsafe class, detailing how to safely obtain its singleton instance, describing its low‑level memory, CAS, thread, class, and object operations, and outlining common high‑performance use cases while warning about the significant risks of misuse.
The article recounts a Java interview where the interviewer explains the memory layout, random‑access capability, and time‑complexity differences between ArrayList (array‑based) and LinkedList (node‑based), using clear examples and code snippets to illustrate fundamental data‑structure concepts.
This article provides a comprehensive overview of Linux’s core architecture, detailing the kernel, memory management, process scheduling, file systems, VFS, device drivers, networking, shells, partitioning, mounting, and essential commands, offering readers a solid foundation for understanding and working with Linux systems.
This article provides a comprehensive guide to Linux memory management, covering memory organization, address spaces, MMU translation, allocation algorithms such as the buddy system and slab allocator, usage scenarios, common pitfalls, and practical tools for monitoring and debugging memory usage.
This article explains how Spark's memory management models and configuration parameters can be tuned to handle massive billing data efficiently, covering StaticMemoryManager vs UnifiedMemoryManager, storage and shuffle memory fractions, common OOM and file‑not‑found issues, and practical performance‑optimisation tips.
This article explains how Redis stores and encodes its five data types by using various in‑memory data structures such as SDS strings, linked lists, quicklists, hash tables, skip‑lists, intsets and zip‑lists, and it also covers object mapping, expiration policies, LRU eviction, and the RDB/AOF persistence mechanisms.
This article compares Redis and Memcached across network I/O models, supported data structures, memory management mechanisms, persistence options, consistency guarantees, and clustering approaches, highlighting the strengths and trade‑offs of each in‑memory data store.
This comprehensive guide explores Linux memory architecture, address spaces, allocation algorithms like the buddy system and slab allocator, DMA handling, user‑space allocation functions, and practical pitfalls, providing developers with essential insights to optimize performance and avoid common errors.
Python’s list type appears flexible, but its underlying CPython implementation uses a dynamic resizing strategy without a pre‑allocated memory pool, allocating memory on demand via list_resize and PyMem_RESIZE, which this article explains through code analysis, memory size measurements, and practical recommendations.
This article explores how JVM memory is allocated, why objects created in methods are not reclaimed instantly, and demonstrates through experiments how Eden space, YGC, and GC behavior affect object lifetimes and overall heap utilization.
This article explains the differences between Java heap and stack memory, their advantages and disadvantages, and demonstrates how string objects are stored and shared using code examples that illustrate memory allocation and reference behavior.
This article investigates why objects allocated in a Java method are not immediately reclaimed after the method exits, demonstrating through experiments how JVM heap regions, especially the Eden space, influence garbage collection timing, and provides practical steps to control memory and CPU usage by deliberately allocating small and large objects.
This article explains how Linux memory management differs from Windows, clarifies the output of the free command—including buffers and cache—and demonstrates the performance benefits of caching through a simple 1 GB file read experiment.
Swift performance hinges on allocation choices, ARC overhead, and method dispatch, so using stack‑allocated structs instead of heap‑allocated classes, applying final or private to force static dispatch, leveraging protocol‑oriented containers, specializing generics, and enabling whole‑module optimization together yield faster, more efficient iOS code.
This article explains the JVM memory architecture—including heap, method area, stack, native stack, and program counter—details how each region is organized, and provides common JVM command‑line options and typical configuration examples for optimizing Java applications.
This article explains Python's integer object implementation, detailing how small integers are cached in a fixed‑size pool, how larger integers are managed through a dynamic PyIntBlock structure, and why using xrange (or range in Python 3) avoids memory bloat.
Linux appears to consume most of a system’s RAM, but the free command’s output, including buffers and cache, actually reflects memory used for performance optimization; this article explains the distinction, how to interpret free’s columns, and demonstrates the impact with a 1 GB file read experiment.
This article explains Linux kernel memory management from a global perspective, covering process address space layout, memory allocation mechanisms, OOM handling, the location of allocated memory, cache behavior, tmpfs usage, and the kernel's automatic memory reclamation strategies.
This article provides a comprehensive overview of Python, covering its nature as an interpreted, interactive, object‑oriented language, key benefits, coding conventions, memory management, debugging tools, core concepts like decorators, data structures, namespaces, lambda functions, testing, and many practical programming details for newcomers.
This article explores the underlying principles of Objective-C objects, analyzing instance objects, class objects, and meta-class objects through memory allocation, data structures, and pointer relationships.
This article details Alibaba’s first production use of non‑volatile memory in the Tair MDB cache service, covering deployment, performance challenges such as write imbalance and lock overhead, the optimizations applied, and design guidelines for building NVM‑based caching systems.
This article explains how memory serves as the main storage for processes, introduces the concepts of virtual memory and paging, and describes how page tables and multi‑level paging enable efficient address translation, isolation, and sharing in modern operating systems.
This article explains how computer memory works, covering physical memory characteristics, address spaces, RAM's random access nature, virtual memory translation, paging mechanisms, page size queries, and multi‑level page tables that enable efficient and secure memory management in Linux.
The article details how Redis’s incremental rehashing can double memory usage and trigger massive key eviction and scan inconsistencies in large‑scale clusters, explains the underlying dictionary structures, demonstrates the cursor bug when tables shrink, and presents a memory‑guard and scan‑cursor patch that resolves both problems.
This article provides a comprehensive overview of Redis, covering why it is used, its performance advantages, data structures, expiration and eviction strategies, cache‑database consistency, handling cache penetration and avalanche, and approaches to concurrent key competition.
This article explains how to overcome the performance, size, memory, and compatibility challenges of deploying deep‑learning inference engines on mobile devices by jointly optimizing model compression and engine implementation, covering speed tricks, cache‑friendly coding, multithreading, sparsity, quantization, NEON intrinsics, package size reduction, memory pooling, and reliability techniques.
This article explains how PHP stores variables using the zval structure, manages memory with reference counting and copy‑on‑write, implements a garbage‑collector based on color marking, and allocates memory through a custom heap that handles small, large, and huge allocations.
This article explains Spark's executor memory architecture, covering on‑heap and off‑heap allocation, static versus unified memory managers, storage and execution memory handling, RDD persistence levels, eviction policies, and shuffle memory usage, providing practical formulas and configuration tips for optimal performance.
This article provides a comprehensive overview of the Java Virtual Machine, covering its cross‑platform nature, core components, class‑loader mechanisms, memory layout, object creation steps, various garbage‑collection algorithms and collectors, as well as common interview questions and answers.
This article explains how Java developers can leverage strong, soft, weak, and phantom references—along with SoftReference, WeakReference, and WeakHashMap—to optimize memory usage, improve cache performance, and demonstrate advanced JVM tuning skills during technical interviews.
Running Java applications inside Docker containers often leads to incorrect memory and CPU allocation because the JVM ignores container limits, but Java 10 introduces native container awareness, allowing proper heap sizing and CPU throttling through updated JVM flags and Dockerfile configurations.
This article explains Linux kernel memory management, covering process address space allocation, OOM selection criteria, memory mapping types, cache behavior, tmpfs, and both manual and automatic memory reclamation mechanisms.
The article examines Flutter’s memory architecture, compares its Image widget’s graphics‑memory usage to Android ImageView’s Java and native heap behavior across OS versions, and evaluates FlutterView integration strategies—showing reuse saves native memory and offering a pre‑render trick to reduce first‑frame latency.
This article explains Linux kernel memory management, covering process address space layout, memory allocation, OOM handling, where allocated memory resides, and both manual and automatic memory reclamation techniques, with practical examples and visual illustrations.
This article provides a comprehensive overview of essential Java fundamentals, covering ThreadLocal, the JVM memory model, garbage collection mechanisms, synchronization primitives like synchronized and ReentrantLock, volatile semantics, concurrency utilities, thread pools, class loading, and common data structures such as HashMap and ConcurrentHashMap.
This article explains how Java's `new` keyword allocates objects on the heap, how object references reside on the stack, the relationship between references and objects, the mechanics of reference assignment, garbage collection conditions, and why Java uses value‑passing for method parameters.
This article provides a comprehensive overview of the Java Virtual Machine, covering its role in Java's cross‑platform execution, internal architecture including class loaders, runtime data areas, execution engine, memory management, and generational garbage collection mechanisms.
This article explains the differences between stack and heap memory on Android devices, outlines typical memory problems such as high usage, leaks, and overflow, and demonstrates practical testing methods using the dumpsys meminfo command and the LeakCanary library with code examples.
This article examines Spark's unified memory manager in version 2.2.1, detailing on‑heap and off‑heap memory regions, the four on‑heap memory pools, dynamic execution‑storage memory sharing, task memory accounting, and provides concrete calculation examples to explain UI discrepancies and runtime memory limits.
This article explains the concept, purpose, and internal architecture of the Java Virtual Machine, compares Java and C program execution, and describes the JVM's class loader, execution engine, and garbage collection subsystems with illustrative code examples and diagrams.
