This article demystifies Linux memory management by explaining why buffers and cache are not meant to be manually cleared, how the 'available' metric differs from 'free', and which sysctl parameters and cgroup settings you should tune to optimize performance and avoid OOM incidents.
This article analyzes the multi‑year modernization of the Linux kernel swap subsystem, detailing the introduction of the swap table, removal of the swap map, virtual swap concepts, and tiered swap designs, and shows how these changes can reduce metadata overhead by up to 30% and improve throughput by 5‑20%.
This article explains how Linux virtual memory lets each process appear to have a large, independent address space by using paging, page tables, swap, and the MMU, covering concepts from basic virtual memory principles to page replacement algorithms and practical tools.
This article explains Linux’s comprehensive memory management system, covering physical and virtual memory concepts, paging, page tables, the MMU, the buddy allocator, slab allocator, memory reclamation strategies such as LRU and swap, monitoring tools, and practical optimization techniques for both user‑space and kernel‑space allocations.
This article walks through Linux performance optimization by explaining core metrics such as throughput and latency, describing how to interpret average load, CPU usage, context switches, memory management, and swap, and showing step‑by‑step usage of tools like vmstat, pidstat, perf, and dstat with concrete command examples and analysis cases.
After noticing 14 GB free RAM but a fully used 29 GB swap, the article explains how to diagnose hidden swap consumption using tools like smem and swap_stat_show, clarifies the difference between free’s Swap used and /proc/*/status VmSwap, and shows how adjusting transparent_hugepage defrag and toggling swap can reclaim the space.
The article walks through a real‑world Linux alert showing a 243% CPU IO Wait, explains how to interpret the metric, gathers system basics, uses iostat, iotop, pidstat and mpstat to probe the IO subsystem, checks disk health, and ultimately discovers the root cause was a mis‑configured Prometheus alert rule.
This comprehensive guide walks you through Linux memory management fundamentals, from prerequisite environments and a quick checklist to step‑by‑step installation of monitoring tools, memory diagnostics, kernel parameter adjustments, THP and swap optimization, NUMA affinity tuning, validation, Prometheus alerts, security hardening, troubleshooting, rollback procedures, best‑practice recommendations, and ready‑to‑use scripts and configuration snippets.
Learn step‑by‑step how to identify why your Linux server’s swap is consuming over 90% of space, understand the performance impact, and apply three safe optimization techniques—including process analysis, swappiness tuning, and cache clearing—to restore smooth operation without rebooting.
Linux swap provides a disk‑backed memory extension, storing anonymous pages when RAM runs low; this article explains swap’s operation, the kernel’s memory reclamation thresholds, tuning parameters like min_free_kbytes and swappiness, and offers commands to locate high‑swap processes and safely clear swap.
A recent Linux kernel patch introduces a unified Swap Table architecture that integrates swap cache, mapping, and allocation, delivering 5%‑20% overall speedups, up to 20% gains in VM scalability, faster builds, and higher Redis/Valkey throughput while reducing memory usage.
This guide covers essential Linux storage management techniques, including how to list devices, mount and unmount filesystems, use the find command for file searches, create and manage disk partitions, configure swap space, and set up disk quotas for user limits.
TencentOS’s recent Swap Table patch series restructures the Linux kernel’s swap subsystem, eliminating long‑standing fragmentation and lock bottlenecks, introducing lock‑free allocation, dynamic swap space, and achieving 20‑30% performance gains and up to 400% higher concurrent throughput in heavy‑load scenarios.
Learn how Linux memory management works, from virtual memory and user/kernel space to allocation, reclamation, and common bottlenecks, and discover practical tools like free, top, vmstat, valgrind, jstat, and swap configuration techniques to diagnose, monitor, and optimize server memory for stable, high‑performance operation.
This article explains Linux's memory reclamation mechanisms, covering the role of memory as the system's bloodstream, the three reclamation paths (fast, direct, kswapd), zone watermarks, page cache structures, reverse mapping, and how swap and compression are used to keep the system stable under memory pressure.
This guide explains what swap space is, why it’s essential for Linux systems, and provides step‑by‑step instructions for configuring swap files or partitions, viewing usage, and understanding its benefits for memory extension, performance optimization, and system stability.
This article explains the ZRAM technology in Linux, covering its principles, configuration steps, kernel integration, performance optimizations, and practical use cases for improving memory utilization on embedded devices, Android, and legacy PCs.
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.
The article provides an in‑depth technical analysis of Linux’s memory reclamation system, covering zones, watermarks, page flags, LRU lists, the shrink_zone workflow, kswapd, direct reclaim, OOM handling, page‑cache structures, and practical tuning tips for optimal 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.
This guide walks through Linux storage fundamentals—including device identification, viewing, mounting (temporary and permanent), file searching, disk partitioning methods, swap setup, device removal, and disk quota configuration—providing practical commands and best‑practice tips for system administrators.
When a small 2 CPU / 2 GB Alibaba Cloud instance runs Java, Nginx, MySQL, and Redis, memory quickly exhausts; this guide shows how to create and configure a swap file, set appropriate permissions, enable it at boot, and tune the swappiness parameter to mitigate out‑of‑memory failures.
This guide explains mounting USB storage, checking device status, configuring NTFS support, and creating, enabling, and disabling swap partitions or swap files on Linux, including practical commands and configuration steps for Ubuntu and CentOS.
This guide explains how to detect and mount USB storage devices on Linux, install NTFS support, view system logs, and set up swap space—either as a dedicated partition or a swap file—while covering swappiness tuning and enabling or disabling swap.
This article explains Linux swap fundamentals, detailing how the kernel uses swap partitions or files, the role of the swappiness parameter in balancing cache reclamation versus anonymous page swapping, the operation of kswapd, and the impact of memory watermarks on reclamation decisions.
In September 2024, TencentOS sent two kernel engineers to Vienna to attend the Linux Plumbers Conference and the Linux Kernel Developers' Netconf, where they presented cutting‑edge research on network diagnostics, SWAP allocation, and memory management, fostering collaboration with leading open‑source contributors.
This article compiles seven hands‑on Linux performance‑optimization practices, covering key factors such as CPU, memory, disk I/O, network, swap usage, and TCP tuning, and provides concrete commands and step‑by‑step troubleshooting methods for system administrators and DevOps engineers.
This guide walks through Linux primary and logical partition concepts, MBR structure, fdisk commands, creating and formatting partitions with XFS, automating mounts, handling large or faulty disks, and setting up swap space for virtual memory.
This guide explains Linux memory management fundamentals and provides step‑by‑step commands for safely clearing RAM caches, file system buffers, and swap space, while highlighting the risks of doing so on production servers and offering advanced tuning techniques.
Large folios in the Linux kernel combine multiple pages to reduce TLB misses, page faults, and reclamation cost while enabling more efficient compression; they are supported by filesystems like XFS and bcachefs, and recent patches add multi‑size THP, swap‑in/out handling, TAO allocation, NUMA balancing, and debug tools, with OPPO’s production deployment showing performance gains and motivating broader adoption and fragmentation mitigation.
This article presents four practical Python techniques—including list reversal, tuple swapping, loop placement, and function‑call reduction—that together can shave roughly 10‑20% off typical script execution times while keeping the code clear and maintainable.
This guide explains the physical structure of mechanical hard drives, how data is organized into sectors, tracks, and cylinders, compares old and new zoning methods, and provides detailed Linux commands for calculating capacity, creating partitions with MBR or GPT, formatting filesystems, and managing mounts and swap space.
Kubernetes v1.30 introduces a range of exciting enhancements—including structured DRA parameters, revamped swap support, beta user‑namespace pods, structured authorization config, container‑resource‑based autoscaling, and CEL‑enabled admission control—each aimed at improving flexibility, security, and operational stability for cloud‑native workloads.
This article explains how to benchmark Redis latency, identify common reasons for slowdowns such as high‑complexity commands, big keys, concentrated expirations, memory limits, fork overhead, swap usage, and CPU binding, and provides detailed configuration and operational steps to monitor and resolve each issue.
This article explains why allocating 8 GB of memory on a 4 GB Linux system can succeed or fail depending on the OS bitness, the overcommit_memory setting, and whether swap is enabled, illustrated with C code experiments, virtual‑memory diagrams, and detailed analysis of OOM handling.
This article explains how to interpret the Linux free command output, clarifies the roles of total, used, free, shared, buffers, and cached memory, describes the -/+ buffers/cache values, and provides commands for manually clearing swap and cache.
The article explains how requesting memory larger than physical RAM interacts with virtual memory, page faults, swap mechanisms, and OOM handling on 32‑bit and 64‑bit operating systems, illustrated with C code experiments and Linux/macOS observations.
Ubuntu 22.04 LTS enables systemd‑oomd by default, but many users report that it unexpectedly kills applications like Firefox, Chrome, and VS Code even without visible memory pressure; Canonical explains the termination conditions, highlights the swap‑size issue, and outlines planned fixes for the upcoming 22.04.1 release.
This article explains Linux memory metrics VSZ, RSS, and PSS, illustrates them with a roommate analogy, details PageCache and its role in I/O, describes swap behavior and the swappiness setting, and introduces zero‑copy techniques to reduce data copying and context switches.
This article explains why Redis latency spikes can cause system-wide outages, shows how to measure baseline performance, monitor slow commands, and address network, RDB, swap, AOF, expiration, and big‑key problems with practical solutions and a diagnostic checklist.
This article explains the fundamentals of virtual memory, including paging, page tables, swap, and Linux management commands, highlighting how virtual memory abstracts physical addresses, resolves process memory conflicts, and enhances security and data sharing while providing practical tips for monitoring and tuning memory usage.
This article explains how Linux manages process memory, covering allocation via mmap and brk, OOM killer selection, the role of page cache in different mapping types, manual and automatic memory reclamation, and related kernel parameters.
This article explains Linux kernel memory management by covering process address space layout, allocation mechanisms, OOM killer behavior, overcommit settings, various types of file and anonymous mappings, tmpfs usage, and both manual and automatic memory reclamation techniques.
This guide explains what Linux swap is, its advantages and drawbacks, how to size it for different memory configurations, and provides step‑by‑step commands for creating, managing, and tuning swap partitions or files, including swappiness and ZFS considerations.
Linux swap extends virtual memory by moving infrequently used pages to disk, and this guide explains what swap is, its pros and cons, sizing recommendations for various RAM amounts, how to create and manage swap partitions or files, and performance tuning tips including swappiness and I/O optimization.
This article explains the fundamentals of Linux virtual memory, covering its origin, paging and page tables, memory addressing, the role of swap, common questions about 32‑bit vs 64‑bit systems, and practical commands for monitoring and configuring virtual memory on Linux.
This article explains the core concepts of Linux virtual memory, including why it exists, how paging and page tables work, the role of the MMU, swap usage, common pitfalls, and practical commands for inspecting and tuning memory behavior on a Linux system.
This article explains Linux virtual memory fundamentals, covering its purpose, paging and page tables, address translation, swap usage, common issues like 32‑bit vs 64‑bit limits, and practical commands such as free, vmstat, pmap, and sysctl for monitoring and configuring memory management.
This guide explains how the Linux free command reports memory usage, clarifies the roles of total, used, free, buffers, and cache, describes the meaning of the -/+ buffers/cache line, and provides practical steps to clear swap and drop caches.
This article explains why a low Redis memory fragmentation ratio is not necessarily caused by swap usage, demonstrates experiments with disabled swap and varying repl‑backlog‑size, and concludes that large replication buffers and small data sets can naturally produce ratios far below 1, which is normal.
This guide explains how to interpret the Linux free command, clarifies the roles of total, used, free, shared, buffers, and cached memory, and provides practical commands to clear swap and drop caches for better system performance.
This article explains the purpose of swap partitions, shows how to check current swap usage, and provides step‑by‑step instructions for creating swap space both via a dedicated disk partition and by using a swap file on a Linux server.
This guide explains how to interpret the Linux free command, distinguishes between used, free, buffers, and cache memory, describes common symptoms of memory pressure, and provides step‑by‑step commands to manually clear swap and drop caches for better system performance.
Linux swap moves anonymous pages to a dedicated swap area—either a partition or a file—using structures such as swap_info_struct, swap_map and swp_entry_t, with a two‑pass swap‑out, per‑CPU slot cache, and SSD‑focused optimizations like clustering and readahead to improve performance.
This article explains why and how to clear Linux RAM cache and swap space using built‑in kernel interfaces, provides three safe echo commands, shows how to automate the process with a cron‑scheduled shell script, and warns against unsafe production usage.
This article explains common causes of Redis latency spikes, such as high‑complexity commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network saturation, and provides step‑by‑step troubleshooting commands and best‑practice recommendations.
This guide explains Linux's memory architecture, how virtual memory (swap) works, and provides step‑by‑step commands to adjust swappiness, release page caches, and safely free swap space, helping you optimize system performance and avoid memory‑related issues.
This article explains the role of virtual memory in Linux, covering the difference between physical and virtual memory, how swapping frees RAM, the two implementation methods—swap partitions and swap files—along with swappiness tuning and the performance benefits they provide.
This article explains Linux's memory architecture, the role of virtual memory and swap, the distinction between buffers and cache, and provides practical commands to adjust swappiness, clear caches, and safely release both RAM and swap space for improved system performance.
This article explains why swapping Integer objects using a simple assignment fails in Java, covering formal vs. actual parameters, value versus reference passing, autoboxing mechanics, the Integer cache, and a reflective workaround that avoids the cache to correctly exchange values.
This article explains that Java passes primitive arguments by value, so attempts to swap two ints inside a method have no effect on the caller, and demonstrates both the faulty implementation and the proper solutions using a temporary variable or a return value.
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.
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.
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.
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 explains the need for virtual memory in Linux, describes its implementation mechanisms such as swap space and lazy allocation, and details the typical layout of the kernel and user address spaces, including high‑memory handling and zone mapping.
Learn how to use the Linux free command to display detailed memory and swap statistics, understand each field—including total, used, free, buffers, cached, and available—interpret the output correctly, and apply common options for human‑readable, periodic, and comprehensive reporting.
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.
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 what Linux swap is, its drawbacks, how to tune the swappiness parameter, methods for monitoring swap usage per system and per process, and practical ways to clear swap, including useful shell scripts and commands.
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.
