0 views collected around this technical thread.
The article explains what page faults are, how the Linux kernel handles them, methods to measure their frequency with tools like perf, vmstat and ftrace, and discusses why frequent faults degrade performance and how to mitigate them through memory, configuration, and code optimizations.
This article explains the principles of CPU cache, the multi‑level memory hierarchy, virtual memory, data consistency, and concurrency control mechanisms, illustrating how they together bridge the speed gap between the fast processor and slower memory/storage in modern computer systems.
This article explains how memory works as a temporary storage stage for processes, describes the fundamentals of physical and virtual memory, details paging, page tables, multi‑level paging, allocation mechanisms such as brk() and mmap(), and outlines Linux memory‑management techniques including caching, swapping, and OOM handling.
Early computers used fixed‑size partitions that wasted space, then dynamic partitions that improved utilization but caused fragmentation, and finally overlay techniques that let programs exceed physical RAM by swapping modules, each step exposing limitations that ultimately drove the creation of virtual memory systems.
This article provides a comprehensive overview of Linux virtual memory, explaining its purpose, page‑based architecture, page‑table mappings, fault handling, swap mechanisms, useful monitoring commands, and practical optimization techniques for both kernel parameters and application code.
This article explains the Linux kernel reverse‑mapping (RMAP) mechanism, covering its historical background, core concepts, key data structures such as anon_vma and anon_vma_chain, and the detailed workflow for page creation, fork handling, and page reclaim or migration, with full code examples.
This article explains the role, operation, and different modes of x86‑64 memory paging, describes how page directories and tables are set up in assembly, shows the relevant control‑register bits, and provides practical code examples for enabling and managing paging in a protected‑mode kernel.
This article explains how Linux-like operating systems use virtual memory and the MMU to map virtual addresses to physical memory, describes the data structures (vma_struct and mm_struct) used by uCore, details the page‑fault handling flow, classifies fault types, and shows how these mechanisms affect system performance.
This guide explains how to create a swap file on a Linux server, enable it, configure it to start at boot, and adjust the swappiness parameter to control virtual memory usage, providing step‑by‑step commands and explanations for each operation.
Adding more RAM only speeds up a computer when the existing memory is insufficient, because RAM supplies data to the CPU and serves as cache; with ample RAM the CPU remains the bottleneck, so extra memory mainly enables more simultaneous programs rather than increasing raw processing speed.
This article explains Linux's paging mechanism, covering the basics of virtual memory, page tables, multi‑level paging structures, virtual memory layout, allocation and reclamation strategies, and the performance and security benefits that paging brings to modern operating systems.
This talk presents the Ant Group team's recent work on large‑model inference memory optimization, covering GPU memory challenges, virtual memory management (VMM), the Virtual Tensor framework, LayerKV techniques, performance comparisons with Page Attention and FlashAttention, and extensive experimental results demonstrating reduced latency and higher QPS.
This article introduces a new book 'Deep Understanding of Linux Processes and Memory' that systematically explains CPU, memory, and process scheduling principles, covering hardware fundamentals, virtual memory, Golang coroutines, container resource management, and performance optimization techniques.
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.
Memory paging, a core memory‑management technique used in modern operating systems and x86‑64 processors, divides physical memory into fixed‑size pages, enabling virtual memory, isolation, sharing, lazy loading, and protection, while the article explains page tables, hierarchical paging modes, and provides assembly code for enabling paging.
This article explains Linux's mmap mechanism, its relationship with shared memory, the advantages and disadvantages of mmap versus traditional shared memory, and provides practical code examples and detailed steps for using mmap in interprocess communication and large‑file handling.
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 explains the fundamentals of memory‑mapped files in Linux, covering the mmap/munmap interfaces, mapping types, protection flags, error handling, virtual‑memory structures, kernel implementation details, driver examples, and practical use‑cases such as shared memory and high‑performance I/O.
This comprehensive guide explains Linux memory management, covering physical and virtual memory concepts, allocation and release methods, related kernel functions, process switching interactions, performance tuning, leak detection, fragmentation handling, and real‑world application scenarios for servers, embedded systems, and driver development.
Virtual memory extends limited physical RAM by giving each process a large address space translated via page tables and a TLB, while multi‑level tables manage size, and the OS separates kernel and user space, offering blocking/non‑blocking, synchronous/asynchronous, multiplexed I/O, reactor patterns, and zero‑copy techniques to optimize data transfer.