Swapping: Diagnostics & Troubleshooting

When Linux runs out of memory

Swapping is a common problem that can occur on a Linux server, especially when the server is under heavy load or has limited memory resources. In simple terms, swapping refers to the process of moving data between physical memory (RAM) and disk storage (swap space) to free up memory for other tasks. While swapping can help alleviate memory pressure, excessive swapping can significantly impact server performance and responsiveness. In this guide, we'll explore what swapping means, why it happens, how to diagnose it, and how to troubleshoot the issue.

What is Swapping?

Swapping is a memory management technique employed by the Linux kernel to efficiently utilize system resources. When a server's RAM is nearly full and more memory is required to run additional processes or applications, the kernel transfers less frequently accessed or inactive data from RAM to disk storage, creating additional space in RAM. This data is stored in a special partition or file called swap space.

Swapping allows the operating system to maintain the illusion of having more physical memory than it actually does. However, accessing data from disk storage is significantly slower compared to accessing it from RAM. Therefore, excessive swapping can lead to a noticeable decrease in server performance.

Why Does Swapping Happen?

Swapping occurs primarily due to memory pressure on the server. When the available physical memory is exhausted and more memory is required, the kernel looks for inactive pages in RAM and transfers them to the swap space. This way, it frees up memory for active processes.

There are a few reasons why swapping may happen:

1. Insufficient RAM: If the server does not have enough physical memory to accommodate all the running processes and applications, swapping becomes necessary to compensate for the memory shortage.
2. Memory leaks: Misbehaving or poorly optimized applications may gradually consume large amounts of memory, leading to memory exhaustion and swapping.
3. Overcommitment: In certain cases, the kernel may allow more memory allocation than the server can physically provide. When the system reaches its memory limits, swapping is triggered.

Diagnosing Swapping

To diagnose swapping on a Linux server, you can use various commands and tools to gather information about the system's memory usage. Here are a few useful ones:

• free: This command displays the system's memory usage, including the amount of free, used, and swapped memory. Running free -h provides a more human-readable output.
• top: The top command shows real-time information about system processes and resource usage. Pay attention to the SWAP column to identify processes that are actively swapping.
• vmstat: By running vmstat 1, you can monitor various aspects of system performance, including the amount of swapping activity. Focus on the si (swap in) and so (swap out) columns.

Troubleshooting Swapping

If you identify excessive swapping on your Linux server, here are some steps you can take to troubleshoot the issue:

1. Analyze memory usage: Use the commands mentioned above (free, top, and vmstat) to identify which processes are consuming the most memory. This can help identify memory-intensive applications that contribute to swapping.
2. Increase physical memory: If the server consistently experiences high swapping and has available memory slots, consider adding more RAM to the system. Increasing physical memory can reduce or eliminate the need for swapping.
3. Optimize applications: Identify memory-hungry applications and consider optimizing their resource usage. This can involve tweaking application settings, configuring connection pooling, or tuning caching mechanisms.
4. Adjust swap settings: You can fine-tune swap behavior by modifying the swappiness parameter. A higher value ( e.g., 60) makes the

kernel more likely to swap, while a lower value (e.g., 10) reduces swapping. Adjusting this value should be done cautiously, taking into account the server's specific workload.

1. Identify memory leaks: Monitor applications for memory leaks, which occur when an application fails to release memory after it is no longer needed. Tools like Valgrind or GDB can help identify memory leaks and assist in fixing them.

It's important to note that swapping is not always indicative of a problem. In some cases, a moderate amount of swapping may be expected and even necessary for the efficient operation of the server. However, excessive swapping leading to performance degradation should be addressed to ensure optimal server performance.

Remember, understanding how swapping works and being able to diagnose and troubleshoot it empowers you to optimize your Linux server's memory usage and ensure smooth operation for your applications.

Detect Swapping with CleverUptime

CleverUptime monitors memory usage and I/O wait and can detect when the system starts excessive swapping. In this case, it will send you an alert, so you can investigate and fix the issue.