This article explains the principles of virtual memory, the data structures and functions used in uCore to manage page faults, and how the operating system handles demand paging, page swapping, and invalid accesses through detailed code examples and workflow descriptions.
The article explains CPython's object memory caching, details the structure of the tuple free‑list, reproduces a bug where length‑20 tuples aren't reused, shows the debugging steps, and presents a one‑line source change that corrects the issue in Python 3.12/3.13.
This article explains Java Metaspace and metadata GC thresholds, compares PermGen with Metaspace, and provides detailed JVM flag configurations—including size settings and compressed pointer options—to help developers optimize memory usage and garbage‑collection performance.
The article explains C’s memory allocation, detailing how functions like malloc obtain heap space, the role of system calls such as brk, the distinction between stack and heap, address layout, fragmentation challenges, and practical implications for efficient dynamic memory management.
This article provides a comprehensive overview of Java's G1 and ZGC garbage collectors, explaining their memory layout, internal structures such as regions, card tables, and RSet, detailing Young and Mixed GC processes, three‑color marking, SATB, incremental updates, and the low‑pause design of ZGC.
The article documents a production incident where each Spring Boot service consumed about 12 GB of memory on a 64 GB server, explains how default JVM settings caused the issue, and provides step‑by‑step troubleshooting and tuning guidance to reduce memory usage.
This article explains the concept, operation, and advantages of PHP generators, demonstrating how they provide memory‑efficient, lazy‑evaluated iteration for large data sets and streams, and includes practical code examples and best‑practice tips for backend developers.
This article presents Xiaomi's work on LLM‑based Agent technology, covering its perception‑thinking‑action pipeline, technical framework, prompt management, executor and API platform, workflow, optimization strategies, evaluation metrics, and future directions for AI assistants.
This article explains Rust’s owned `String` type, showing how to create strings, grow and modify them with various methods, and convert between `String` and `str` while highlighting ownership and borrowing concepts essential for safe memory management.
This article explains the WorkingSet metric in Kubernetes, shows how to calculate it with cgroup v1 and v2 scripts, outlines common container memory issues such as the memory black‑hole, and presents troubleshooting steps using SysOM monitoring and Koordinator QoS to resolve high WorkingSet usage.
This article answers twenty‑seven common Python questions covering why indentation is used for block grouping, the reasons behind surprising floating‑point results, the immutability of strings, the explicit use of self, the absence of assignment in expressions, and many other design choices that shape Python’s core behavior.
Over the past six months we tackled severe Android memory issues—high OOM crash rates, memory leaks, and large object usage—by implementing systematic profiling, targeted page optimizations, Java and native leak detection tools, and robust monitoring mechanisms, ultimately reducing OOM crashes from 0.8‰ to 0.01‰ and improving app stability.
This article delves into Rust’s Vec type, explaining its internal structure—including pointer, length, and capacity—detailing essential methods such as push, pop, len, capacity, and iter, and provides practical code examples that illustrate creation, manipulation, iteration, and performance considerations.
This article explains Go's pointers, slices, and maps, detailing their internal relationships, demonstrating how slices share underlying arrays via pointers, and showing how maps store pointers for efficient data access, accompanied by practical code examples and usage tips for safe, high‑performance programming.
This article introduces the open‑source mem_malloc module for microcontrollers, explains its fragmentation‑free allocation algorithm, shows how to integrate and compile it on an IOT development board, and provides detailed test code and results illustrating efficient RAM usage.
This article explains the fundamentals of garbage collection, compares manual and automatic memory management, outlines common GC algorithms, and provides practical guidance on performance analysis, tool selection, and optimization techniques to improve application responsiveness and resource utilization.
This article explains Redis's memory model—including memory statistics, allocation, internal data structures, object types, and encoding—while showing practical examples for estimating usage, optimizing consumption, and troubleshooting fragmentation in high‑concurrency environments.
This article explores Go's experimental arena library, detailing its design principles, core features such as fast allocation and memory reuse, suitable use cases like object pools and game development, provides a practical code example, and discusses performance benefits and limitations for high‑concurrency applications.
This article consolidates DPDK 17.11 source‑code notes to explain the library’s memory‑management subsystem, covering hugepage concepts, shared configuration mapping, NUMA‑aware allocation, and the custom allocator that enables high‑throughput packet processing on Linux.
This comprehensive guide explains Linux memory fundamentals, address space layout, fragmentation, the buddy and slab allocators, kernel and user‑mode memory pools, DMA handling, common programming pitfalls, and practical tools for monitoring memory usage.
This comprehensive guide explores Linux memory architecture, address spaces, allocation strategies like the buddy and slab allocators, user‑ and kernel‑level memory management, DMA, and practical tips to avoid common memory bugs and performance issues.
This article provides a comprehensive guide to Linux memory management, covering memory fundamentals, address spaces, MMU translation, segmentation and paging, the buddy and slab allocation algorithms, kernel and user memory pools, typical usage scenarios, common bugs, and practical tools for monitoring and debugging memory usage.
This article explains how Go's sync.Pool can reduce memory allocations and garbage‑collection overhead in high‑performance applications, provides step‑by‑step usage examples, demonstrates a byte‑buffer pool, shows performance benefits, and visualizes the mechanism with UML class and sequence diagrams.
This article provides a comprehensive overview of Netty's core layers, protocol support, transport services, logical architecture, various I/O models, packet framing techniques, custom protocol design, write‑and‑flush behavior, off‑heap memory management, and high‑performance data structures such as FastThreadLocal and HashedTimerWheel.
This article explains the principles of object pools, details the internal implementation of Go's sync.Pool, and demonstrates through benchmarks how using an object pool can dramatically reduce memory allocation and latency for high‑traffic menu services in a restaurant ordering application.
This article explains why garbage collection (GC) is essential, defines key GC terminology, compares performance metrics, and provides a detailed overview of seven common GC algorithms—including mark‑sweep, reference counting, copying, mark‑compact, conservative, generational, and incremental GC—along with their advantages, disadvantages, and typical improvements.
The article surveys seven common garbage‑collection algorithms—Mark‑Sweep, Reference Counting, Copying, Mark‑Compact, Conservative, Generational, and Incremental/Tri‑color—explaining their principles, strengths, weaknesses, evaluation criteria such as throughput and pause time, and practical optimizations, emphasizing that the best choice depends on specific application needs.
This comprehensive Q&A explains Linux system composition, kernel placement, core subsystems, address translation, paging structures, process concepts, scheduling algorithms, interrupt handling, system calls, synchronization, deadlock avoidance, and the virtual file system, providing a solid foundation for operating‑system fundamentals.
This article explains how to handle log files that are too large to fit into memory by reading them line‑by‑line with Java streams, using a Counter class and BitSet to track service usage and efficiently generate a top‑10 report.
This article explains why Java's String class is immutable, detailing the benefits such as thread safety, cached hash codes, and string pooling, and describes the internal mechanisms—including a private final char array, creation of new objects on concatenation, and the intern method—that enforce this immutability.
This article examines Alibaba Cloud's TorchAcc framework, a TorchXLA‑based distributed training solution that automates parallel strategies, optimizes memory, computation, and communication, and delivers up to three‑fold speedups for large models such as Llama 2‑7B.
This article provides a comprehensive guide to JVM internals, covering runtime data areas, heap segmentation, object allocation, reference types, class loading phases, garbage collection algorithms, collector choices across JDK versions, performance tuning commands, and practical troubleshooting techniques for production Java applications.
The article offers a thorough overview of Java 8 memory management, detailing JVM memory regions, object eligibility, major garbage‑collection algorithms and generational models, comparing Serial, Parallel, CMS and G1 collectors, and presenting practical heap‑dump analysis techniques for diagnosing leaks and performance issues.
This article explores six typical OutOfMemoryError situations in Java—including heap, stack, direct memory, GC overhead, and metaspace issues—explains their root causes, provides reproducible code examples, and offers practical tips to avoid or mitigate each problem.
This article dissects Redis's memory architecture, explains each memory component, walks through object encoding rules, buffer handling, fragmentation, and child‑process memory, then presents two production incidents with step‑by‑step analysis and concrete optimization actions to prevent future memory alarms.
This article explains how PHP’s automatic garbage collector works, detailing reference‑counting, zval structures, handling of scalar and composite types, cycle detection, configuration options, and practical debugging techniques using Xdebug and code samples.
This article provides concise explanations and code examples for common interview questions covering C global variable defaults, binary representations, finding top‑k elements, double‑pointer and binary search techniques, OOP concepts in C, differences between C++ class and struct, UDP packet limits, TCP read() return values, memory leaks in infinite loops, and resource cleanup on process exit.
This guide explains how JVM determines heap size on physical machines versus containers, compares behavior of different JDK releases, and provides concrete Docker commands and JVM flags—such as -Xms/-Xmx, -XX:+UseCGroupMemoryLimitForHeap, and MaxRAMPercentage—to reliably control memory usage in containerized Java applications.
This article explains how Linux reports memory usage, covering the free command output, the evolution of buffer and page caches, detailed /proc/meminfo fields, shared memory accounting, kernel memory statistics, huge pages, and per‑process metrics such as smaps and top.
This article explains PHP's key memory management functions—including memory_get_usage, memory_get_peak_usage, gc_collect_cycles, and the memory_limit setting—providing usage syntax, examples, and guidance on optimizing script performance and preventing memory‑related issues.
This guide explains why Linux servers run out of memory or disk space, how to create and enable swap files, locate and remove large or numerous small files, use soft links to expand storage, and release space held by deleted files still opened by processes.
The article explains Dart VM’s generational garbage collection, detailing object allocation, the young‑generation Scavenge copying collector, old‑generation Mark‑Sweep and Mark‑Compact algorithms, safepoints, write‑barrier mechanics, debugging a write‑protect crash, and the importance of logging for memory‑management analysis.
Linux’s shmem subsystem provides hybrid anonymous/file‑backed pages that enable diverse shared‑memory scenarios—parent‑child communication, IPC, tmpfs, Android ashmem, and memfd—by using APIs such as shmem_file_setup, handling page faults through cache and swap mechanisms, and employing a specialized reclamation process to manage memory efficiently.
This article introduces Colossal‑AI, an open‑source platform that tackles the challenges of training, fine‑tuning, and deploying massive AI models by leveraging efficient memory management, N‑dimensional parallelism, and high‑performance inference to dramatically reduce cost and improve scalability across thousands of GPUs.
This article analyzes a MySQL 5.7 OOM incident triggered by a heavy full‑text query, examines memory usage patterns with Tcmalloc, demonstrates how switching to Jemalloc releases memory, and provides step‑by‑step commands and observations to prevent similar outages.
Redis implements its own Simple Dynamic String (SDS) instead of plain C strings because SDS stores length for O(1) queries, pre‑allocates extra space and lazily reuses freed bytes, prevents buffer overflows, handles binary data, and uniformly backs all string keys, values and container elements.
This article explains how circular references cause memory leaks in Python, describes the role of reference counting and the cyclic garbage collector, and provides practical examples using the weakref and gc modules to create weak references, detect, and manually manage cyclic garbage.
This article explains how to estimate capacity, choose appropriate garbage collectors, and configure JVM memory settings—including heap size, young generation, thread stack, and GC options—for a service that processes one million login requests per day on a node with 8 GB of RAM, providing step‑by‑step guidance and example command lines.
To cope with soaring traffic on Bilibili’s effect‑advertising engine, the team systematically measured latency, eliminated redundant Redis calls, switched JSON to Protobuf, applied branch‑prediction hints, loop‑unrolling and AVX256 SIMD, introduced object‑pooling and an inverted‑index request format, cutting CPU usage by 21 % and boosting peak throughput 13 %.
This article presents seven practical, long‑term strategies—such as ROM filling, CRC checks, RAM validation, stack monitoring, MPU usage, robust watchdog design, and avoiding volatile memory allocation—to help embedded engineers build more reliable firmware and catch abnormal behavior early.
This article explains how to implement file caching and effective memory management in PHP, providing step‑by‑step instructions and code examples for creating cache directories, generating cache filenames, checking and clearing caches, and releasing variables and objects to prevent memory leaks.
This article explains how the Linux kernel allocates dynamic memory, distinguishes kernel and user‑space allocation strategies, describes the mm_struct layout of a process address space, and shows how pages and page tables translate virtual addresses to physical memory.
Python automatically manages memory through garbage collection, and this article explains how the garbage collector works and presents ten practical techniques—including manual gc calls, generators, sys.getsizeof, slice copying, del statements, sys.intern, NumPy, pandas, reference counting, and __slots__—to reduce memory usage and improve performance.
This article explains why Java processes in Kubernetes pods often encounter OOMKilled despite correct JVM heap settings, analyzes the discrepancy between JVM‑reported memory and container metrics, and provides practical steps such as adjusting MaxRAMPercentage and pod memory limits to stabilize memory usage.
This comprehensive guide presents 65 common embedded‑system interview questions covering topics such as memory layout, stack vs. heap, static and volatile keywords, pointers and references, malloc usage, C vs. C++ differences, compilation stages, process and thread concepts, IPC mechanisms, and networking fundamentals, providing concise explanations and code examples for each.
The article examines AutoGPT's shift away from vector databases, detailing the original vision of using embeddings for long‑term memory, the performance calculations that exposed unnecessary complexity, the adoption of JSON‑based storage, and the emerging trend of specialized multi‑agent architectures.
This article explains how using larger Linux page sizes—especially 2 MB hugepages—dramatically improves database throughput on Kubernetes nodes by reducing TLB cache misses, and provides practical guidance on configuring hugepages, disabling transparent hugepages, and sizing resources for optimal performance.
This article walks through practical techniques for removing duplicates from massive Python datasets—such as using tuples with sets, merging iteratively, and concatenating with drop_duplicates—while highlighting memory pitfalls and offering concise code snippets.
This article explains the common Java OutOfMemoryError types—including heap space, GC overhead limit exceeded, Metaspace, CodeCache, Direct Memory, and Linux OOM Killer—detailing their causes, symptoms, and step‑by‑step troubleshooting techniques for backend developers.
This article explains the various Java OutOfMemoryError types—including Java heap space, GC overhead limit exceeded, Metaspace, CodeCache, Direct Memory, and Linux OOM Killer—describes their causes, typical symptoms, and provides step‑by‑step troubleshooting and mitigation strategies for developers.
This article explores the motivation, design, implementation, and performance testing of a high‑performance object pool that reduces allocation overhead in multithreaded environments by using thread‑local storage, freelists, and lock‑optimized global resources.
The article traces a production bug where unreleased JDK ThreadLocal data corrupted user info, then compares JDK ThreadLocal with Netty’s FastThreadLocal, detailing their source‑code implementations, performance trade‑offs (O(n) vs O(1) access), memory‑leak risks, and recommends explicit remove() calls to avoid leaks.
This article explains how Linux organizes physical memory, allocates pages using the buddy system and SLUB, structures virtual address spaces for user and kernel modes, and maps virtual addresses to physical memory through page tables, TLBs, and dynamic mappings.
This article explains Redis's two expiration mechanisms—lazy (access‑time) and periodic deletion—then dives into the source code of lookupKey, expireIfNeeded, deleteExpiredKeyAndPropagate, and the underlying delete functions, highlighting the differences between synchronous and asynchronous deletion, the conditions that prevent deletion of expired keys, and practical recommendations for configuring lazyfree.
This article explains what Java OutOfMemoryError (OOM) is, outlines the most common OOM types such as Java heap space, GC overhead limit, Metaspace, and native thread exhaustion, provides sample code for each, and suggests basic mitigation strategies like adjusting JVM options or optimizing code.
This article explains the challenges of memory management in mixed workloads, outlines the limitations of native Linux and Kubernetes mechanisms, and details how ByteDance’s open‑source Katalyst Memory Advisor improves memory utilization, QoS, and eviction handling through user‑space policies, multi‑dimensional interference detection, and adaptive mitigation actions.
This article explains the challenges of memory management in mixed Kubernetes workloads, introduces ByteDance's open‑source Katalyst Memory Advisor, details native allocation and reclamation mechanisms, outlines its architecture and plugins, and describes interference detection and multi‑level mitigation strategies to improve memory utilization and service quality.
This article explains the Java Virtual Machine's memory architecture—including heap, method area, stack, program counter, and non‑heap memory—details common garbage‑collection algorithms such as mark‑sweep, copying, mark‑compact, and generational, and outlines Java's memory‑management practices like object lifecycle, memory partitioning, references, and synchronization.
The article outlines the major performance and architectural goals for Python 3.12, describing the Faster CPython project’s specialized opcodes, multithreading proposals, object size reductions, memory‑management improvements, and API stability efforts that aim to boost speed and maintainability.
This article explains Redis’s five core data object types—strings, lists, hashes, sets, and sorted sets—detailing their encoding schemes, underlying memory structures such as SDS, ziplist, linkedlist, hashtable, and skiplist, and how Redis optimizes storage and access performance.
This article explains how Java objects are created using the new operator, details the JVM memory model (stack and heap), describes the generation and loading of .class files by the ClassLoader, compares Class.newInstance() with new, and outlines the initialization steps and key concepts developers must master.
This guide explains typical C memory‑allocation errors, practical ways to avoid them, and introduces a lightweight logging system that automatically records allocations and frees to help developers detect memory leaks during debugging.
This article explains how Netty implements memory management by borrowing concepts from Jemalloc and Tcmalloc, detailing the hierarchy of arenas, chunks, pages and sub‑pages, the allocation algorithms for both large and small buffers, and the role of thread‑local caches in reducing fragmentation and improving performance.
This guide explains how high concurrency and fast response depend on throughput and latency, defines key performance metrics, shows how to interpret average load, CPU context switches, and memory usage, and provides practical Linux tools and command‑line examples for diagnosing and tuning system performance.
This article provides a comprehensive overview of the Java Virtual Machine's runtime memory areas, object layout, garbage collection roots, marking algorithms, generational hypotheses, remembered sets, and the main GC algorithms such as Mark‑Sweep, Mark‑Copy, and Mark‑Compact, explaining their principles and trade‑offs.
This article explains Linux's memory management, detailing how physical memory is organized into pages, zones, and nodes, how virtual addresses are structured for user and kernel space, and how page tables, the buddy system, SLUB, and TLB work together to map virtual addresses to physical memory.
This article presents a comprehensive list of thirty‑one practical Java performance optimization techniques—including proper use of singletons, avoiding static variables, minimizing object creation, leveraging final modifiers, choosing appropriate collections, and efficient exception handling—to help backend developers write faster, more memory‑efficient code.
DGraph, a C++ recommendation engine launched in 2022 for 得物, combines an index layer with a service layer, uses lock‑free RCU structures, a custom mmap‑based D‑Allocator, RoaringBitmap invert indexes, and a multi‑operator fusion scheduler to achieve high‑performance, eventually consistent, scalable recommendations.
This article provides a comprehensive overview of the eight Java garbage collectors, detailing their target heap generations, operational characteristics, configuration flags, and suitability for different application performance and latency requirements.
This article examines how Linux page size, especially the use of huge pages (2 MB and 1 GB), influences database throughput by reducing TLB misses, presents benchmark results, and offers practical guidance for configuring Kubernetes nodes to leverage large pages for optimal database performance.
This article explains the architecture of TDSQL-C Serverless buffer pool, details how InnoDB buffer pool resize works, analyzes performance bottlenecks such as IO and mutex contention, and presents optimization techniques like chunk pre‑allocation, delayed release, and hash‑resize improvements that make serverless scaling more stable.
This article explains the concept of automatic garbage collection in Java, detailing the mark‑sweep‑compact process, the need for generational collection, and how objects move through Eden, Survivor, and Old generations, while also noting promotional links for further resources.
This article demonstrates how to generate, read, and analyze a 10 GB file of age statistics on a 4 GB RAM, 2‑core machine using Java, comparing a single‑threaded counting method with a producer‑consumer multi‑threaded approach that dramatically improves CPU utilization and reduces processing time.
This article presents ten practical Python code examples demonstrating various garbage collection mechanisms and memory‑analysis tools, including reference counting, cyclic references, object inspection, tracemalloc, memory_profiler, pympler, and objgraph, to help developers understand and optimize memory usage.
The article explains that an operating system acts as a resource allocator, isolates processes to maintain system order, and abstracts hardware complexities, using examples of CPU scheduling, memory management, and networking to illustrate why OSes are essential for modern computing.
This article explains the core trade‑offs of JVM tuning—short pause times versus high throughput—provides quantitative goals, outlines when tuning is needed, details step‑by‑step optimization procedures, and lists common GC strategies and command‑line parameters for effective Java performance tuning.
This article explains DPDK's memory management architecture, covering the hierarchical memory layout, hugepage discovery and mapping, shared configuration structures, NUMA‑aware allocation, custom malloc‑heap implementation, memzone and mempool creation, and the mbuf buffer model, with detailed code examples.
This article provides a concise yet comprehensive overview of the Java Virtual Machine, covering its core components, how Java source files are compiled and executed, class‑loader mechanisms, runtime memory areas, garbage‑collection algorithms, and practical JVM tuning parameters for optimal performance.
This article investigates why OceanBase's memory freeze threshold changes during load testing by analyzing monitoring data, inspecting the relevant source code, and demonstrating debugging steps, ultimately revealing that the threshold is computed dynamically based on real‑time memory usage and can be lowered when other memory modules consume space.
This article walks through the Linux kernel's memory‑management subsystem, explaining how virtual memory is linked to physical memory via page tables, covering single‑level, two‑level and multi‑level paging, the structure of page‑table entries, the role of the MMU and TLB, and the complete CPU address‑translation process.
This comprehensive guide explains how to containerize Java applications by choosing appropriate base images, deciding between JDK and JRE, selecting a JVM, handling graceful shutdown signals, configuring memory limits, managing DNS caching, and optionally compiling to native binaries with GraalVM.
This comprehensive guide explores Linux memory fundamentals, address space layout, fragmentation, the buddy and slab allocation algorithms, kernel and user‑space memory usage scenarios, and common pitfalls, providing backend developers with practical insights to improve performance and stability.
Redis implements approximate LRU and LFU eviction policies by sampling keys and using a compact 24‑bit field to store timestamps and counters, where LRU evicts the least recently accessed items and LFU evicts those with low, decay‑adjusted access frequency, each with trade‑offs for different workloads.
Linux kernel introduced the struct folio abstraction to replace ad‑hoc compound‑page tricks, giving a clear collection‑oriented representation for power‑of‑two page groups such as THP and HugeTLB, and providing dedicated APIs that eliminate naming confusion, unify reference handling, and make memory‑management code safer and easier to understand.
This comprehensive guide covers Linux memory management fundamentals, detailing physical and virtual memory concepts, allocation and release mechanisms, key kernel functions, code examples, process switching, performance tuning, leak detection, fragmentation mitigation, and real‑world applications across system, driver, and optimization layers.
This article explains how Linux manages memory by organizing physical pages, using zones and nodes, allocating memory with the buddy system and SLUB, structuring user and kernel virtual address spaces, and translating virtual addresses to physical ones via page tables, TLBs, and dynamic mapping.
The article outlines the Shannon Plan, a multi‑year effort led by CPython core developers to accelerate Python by introducing a Tier 2 optimizer, enabling sub‑interpreters via PEP 554, and improving memory management, with the ultimate goal of making Python five times faster by version 3.13.
This article compares the memory management and garbage collection architectures of Java and Go, detailing their heap and stack regions, GC trigger conditions, collection algorithms, fragmentation handling, root object selection, and write‑barrier strategies, and includes illustrative code examples.
LangChain, launched in 2022, quickly evolved from a Python library to a multi‑environment framework that helps developers build chat‑based applications, agents, and memory‑aware LLM solutions, while integrating with major cloud and AI tooling ecosystems.
This book explores fundamental computer science concepts including programming language execution, compiler operations, memory allocation mechanisms, and system architecture through accessible explanations and practical examples.
