SoFunction
Updated on 2025-05-22

Share five practical tips for Linux memory management optimization

introduction

In modern computing environments, memory management is one of the core links in operating system performance optimization. For Linux systems, the efficiency of memory management directly affects the system's response speed, stability and resource utilization. Whether it is an individual developer or an enterprise-level server administrator, when facing memory resource tightness or system performance bottlenecks, you need to master some key memory management optimization skills.

This article will start from the basic principles of Linux memory management and combine it with practical application scenarios to share five practical optimization techniques. Through these techniques, you can significantly improve the operating efficiency of your system and maintain the stability and smoothness of your system in high load environments.

text

1. Understand the basic principles of Linux memory management

Before we dive into optimization techniques, we need to understand the basic mechanisms of Linux memory management. Linux uses a virtual memory management system (VMM) to manage physical memory and swap space (swap). Virtual memory allows the system to use physical memory with disk space, thus providing applications with greater available memory space.

Key components of Linux memory management include:

  • Physical Memory (RAM): Used to store running applications and data.
  • Swap: When physical memory is insufficient, the system will move some of the infrequently used memory contents to the swap partition on the disk.
  • Page Cache: Used to cache file system data to improve I/O performance.
  • Anonymous Pages: Stack and heap data used to store processes.
  • ** slab allocator**: Used to manage the cache of kernel objects.

Understanding these concepts will help us better understand subsequent optimization strategies.

2. Tips 1: Adjust swappiness parameters

swappinessis an important kernel parameter used to control the frequency of the system using swap partitions. By default, it is set to 60 (range 0-100) in most Linux distributions. A higher value indicates that the system tends to move memory contents to the swap partition; a lower value indicates that it tends to retain contents in physical memory.

Why is swappiness important?

  • ifswappinessSetting too high (for example close to 100) may result in performance degradation in the system by over-rely relying on swap partitions.
  • ifswappinessSetting too low (e.g. close to 0) may cause the application to be killed to free resources when physical memory is insufficient.

How to adjust swappiness?

You can view the current commandswappinessvalue:

cat /proc/sys/vm/swappiness

Temporary adjustmentswappinessValue:

sudo sysctl =20

Always take effect and need to modify the configuration file:

echo "=20" | sudo tee -a /etc/
sudo sysctl -p

Recommended settings:

  • For desktop environments or lightweight servers, the default setting is 60.
  • For high-performance computing or database servers, it is recommended toswappinessSet to a lower value (such as 10 or 20) to reduce disk I/O overhead.

3. Skill 2: Optimize process priority and resource allocation

Linux provides a wealth of tools to control process priorities and resource allocation policies. By rationally configuring the process scheduling policy, the overall performance of the system can be significantly improved.

Common tools and commands:

  • nice and renice

    • niceThe command is used to start a new process with a specific priority.
    • reniceCommands are used to adjust the priority of running processes.

    Example:

# Start a low priority tasknice -n 19 ./my_script.sh

# Adjust the priority of process with PID 1234 to -5sudo renice -n -5 -p 1234

ionice

  • ioniceCommands are used to control the process's I/O scheduling priority.

Example:

# Set process with PID 1234 to low priority I/O operationsudo ionice -c3 -p 1234

cgroups

  • Control Groups (cgroups) is a functional module of the Linux kernel. By default, it supports resource restrictions such as CPU, memory, disk I/O, etc.

Example:

# Create a cgroup named "mygroup" and limit its maximum memory to 5GBsudo cgcreate -g memory:/mygroup
echo "5G" | sudo tee /sys/fs/cgroup/memory/mygroup/

By reasonably allocating process priorities and resource restriction policies, some high-load tasks can avoid system stuttering due to excessive resources.

4. Tips 3: Analyze and monitor memory usage

Timely discovering and resolving memory leaks or overused applications is one of the key steps in optimizing memory management. Linux provides a variety of tools to help us analyze and monitor memory usage.

Common tools and commands:

  • top and htop
    • topIt is a classic tool that displays the usage of system resources in real time.
    • htopyestopThe enhanced version provides more intuitive interface and interactive functions by default.
  • free
free -h

This command displays the total amount of memory of the system and the amount of memory used in a human-readable manner.

  • vmstat
vmstat -s

This command displays detailed virtual memory statistics.

  • pmap
cat /proc/meminfo | grep MemTotal:

This file provides detailed statistics on kernel virtual memory information.

By monitoring these metrics regularly, combined with log analysis tools (e.g.dmesgorjournalctl), can quickly locate the root cause of the problem that leads to high memory volume.

5. Tips 4: Enable Transparent Huge Pages

Transparent Huge Pages (THP, Transparent Huge Pages) is a technology designed to improve the efficiency of virtual address to physical address translation. It reduces the number of TLB (Translation Lookaside Buffer) missing times and improves cache hit rate by merging multiple small pages (usually 4KB) into a large page (usually 2MB or 1GB).

How to enable THP?

By default, THP is enabled in most modern Linux distributions. You can check the current status by:

cat /sys/kernel/mm/transparent_hugepage/enabled

If the output is similar[always] madvise neverIt means that THP is enabled and in default mode (alwaysRun under )

For certain specific application scenarios (such as database servers or virtualization environments), further THP configuration may be required to achieve better performance improvements:

# Enable THP and set to madvise mode:echo madvise > /sys/kernel/mm/transparent_hugepage/enabled

# It needs to be modified to take effect permanently:echo "transparent_hugepages=always" | sudo tee /etc/default//transparent_hugepages.cfg && sudo update-grub && reboot

It should be noted that in some cases over-enablement of THP may cause increased page replacement overhead and cause performance problems. Please test and adjust according to the specific scenario.

6. Tips 5: Configure the appropriate file caching policy

File caching is one of the very important components of Linux systems and plays a key role in improving I/O performance. A rational configuration file caching strategy can help us better utilize the limited amount of physical memory to improve overall system performance.

Key parameter description:

  • vm.dirty_ratio and vm.dirty_background_ratio

These two parameters control the proportional threshold for dirty pages to be written back to disk:

  • When the dirty page ratio reaches dirty_ratio%, synchronous write back operation is triggered;
  • When the dirty page ratio reaches dirty_background_ratio% the asynchronous write back operation is triggered;

By default:

  • vm.dirty_ratio = 20%
  • vm.dirty_background_ratio = 10%

For high load I/O scenarios, it is recommended to appropriately raise the dirty_ratio threshold to reduce the performance overhead caused by frequent synchronous writebacks:

echo "vm.dirty_ratio=40" | sudo tee /etc/ && sudo sysctl -p

echo "vm.dirty_background_ratio=25" | sudo tee /etc/ && sudo sysctl -p
  • vm.vfs_cache_pressure

This parameter controls the probability that the directory item and inode buffer are recycled, and the default value is 60:

echo "vm.vfs_cache_pressure=50" | sudo tee /etc/ && sudo sysctl -p

Reducing vfs_cache_pressure can reduce the possibility of file metadata being recycled and improve file operation efficiency; however, for application scenarios that frequently create large amounts of temporary files, it may be necessary to appropriately increase this value to avoid excessive memory consumption.

Summarize

Through the learning and practical application of the above five key techniques, we can effectively improve the overall performance of the Linux system in our daily work, especially when facing complex and changeable workloads, we can more calmly respond to various challenges.

Of course, memory management and performance optimization are a process of continuous improvement, and it requires continuous testing and adjustments based on specific application scenarios to achieve the best results. I hope that the content shared in this article can help you better understand and master the core points of Linux memory management, so that your system can run smoothly and efficiently!

The above are the detailed contents of five practical tips for Linux memory management optimization. For more information about Linux memory management optimization, please pay attention to my other related articles!