High Memory Load in Linux: Causes and Solutions

Introduction

The issue of high RAM (Random Access Memory) consumption in Linux is one of the most common reasons for system slowdowns and application crashes. When RAM is exhausted, the Linux kernel activates the OOM Killer (Out of Memory Killer), which forcefully terminates processes to free up resources. This article discusses methods for diagnosing, analyzing, and resolving high memory load issues.

Symptoms of the Problem

Before moving on to diagnostics, it's important to recognize the main signs of high memory consumption:

• System Slowdown — applications take a long time to start and respond to user actions
• Frequent Freezes — the system stops responding to requests
• Log Messages — appearance of entries like Out of memory: Kill process in /var/log/messages or dmesg
• Active Swap Usage — the system is actively working with the swap partition
• Application Errors — programs crash with messages about insufficient memory

Memory State Diagnosis

Basic Check with free

The first command to run when suspecting memory issues:

free -h

Example output:

              total        used        free      shared  buff/cache   available
Mem:           15Gi       8.2Gi       2.1Gi       345Mi       4.6Gi       6.3Gi
Swap:         2.0Gi       1.5Gi       500Mi

It's important to understand: the buff/cache column shows memory used by the system for file caching. This is not a problem — Linux will automatically free this memory when applications need more RAM. Focus on the available column.

Identifying Memory-Consuming Processes

To find processes that are using the most RAM, use:

ps aux --sort=-%mem | head -n 15

The output will show:

• USER — owner of the process
• PID — process identifier
• %MEM — percentage of RAM usage
• RSS — size of the resident set of the process (in Kb)
• COMMAND — command that started the process

To get information about a specific process:

pmap -x <PID>

or

cat /proc/<PID>/status | grep -E "VmRSS|VmSize|VmData"

Real-Time Monitoring

Interactive utilities for monitoring:

htop

or

top

In htop, press M to sort by memory usage. In top, use the M command after starting.

Checking Swap Usage

Active use of swap space indicates a lack of RAM:

vmstat 1

Pay attention to the si (swap in) and so (swap out) columns. Values other than zero for an extended period signal a problem.

swapon --show

This command will show all swap partitions and files.

Typical Causes of High Memory Consumption

1. Memory Leaks in Applications

Poorly written programs may allocate memory and not free it. A memory leak can be identified by a gradual increase in memory consumption by a specific process over time.

2. Too Many Running Processes

Many background processes that start automatically can collectively consume a significant amount of RAM.

3. Insufficient Amount of RAM

Modern tasks may require more RAM than is installed in the system.

4. Incorrect Swapping Settings

The vm.swappiness parameter determines the aggressiveness of swap usage. The default value is 60, which may be too high for servers.

5. File System Caching

Linux actively caches files in memory. If misconfigured, this can lead to problems.

Problem-Solving Methods

Optimizing Kernel Parameters

Adjusting the vm.swappiness parameter:

# View current value
cat /proc/sys/vm/swappiness

# Temporary change (until reboot)
sysctl vm.swappiness=10

# Permanent change
echo "vm.swappiness=10" >> /etc/sysctl.conf
sysctl -p

Recommended values:

• 10-30 — for servers with sufficient RAM
• 60 — default value
• 90-100 — for systems with very little RAM

Clearing Page Cache

Warning: Do not perform on production servers without extreme necessity.

# Clear page cache (only with root privileges)
sync && echo 3 > /proc/sys/vm/drop_caches

This command will clear the page cache, dentries, and inodes. The effect will be temporary.

Optimizing Running Processes

1. Identify unnecessary processes:

   systemctl list-units --type=service --state=running
   

2. Disable autostart of unnecessary services:

   systemctl disable <service_name>
   

3. Stop processes manually:

   kill -15 <PID>  # soft termination
   kill -9 <PID>   # force termination (if not effective)
   

Configuring OOM Killer

You can configure the behavior of the OOM Killer for specific processes:

# Set OOM priority for the process (from -17 to 0)
echo -17 > /proc/<PID>/oom_score_adj

The value -17 completely excludes the process from being terminated by the OOM Killer.

For daemons and important services, add to the systemd unit:

[Service]
OOMScoreAdjust=-1000

Increasing Swap Space

If physical memory is insufficient, create an additional swap file:

# Create a 2 GB swap file
fallocate -l 2G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile

# Add to fstab for permanent mounting
echo '/swapfile none swap sw 0 0' >> /etc/fstab

Preventing Memory Issues

1. Regular Monitoring — set up system metrics to track memory usage
2. Application Optimization — use profilers to find memory leaks in code
3. Proper Planning — choose the amount of RAM according to workload requirements
4. System Updates — use current versions of the kernel and system libraries

Conclusion

High memory consumption in Linux is a complex issue that requires a systematic approach to diagnosis. Start by monitoring the system state using the free and ps commands, identify memory-hungry processes, and optimize their operation. Adjusting kernel parameters and properly configuring swap will help prevent future issues.

If standard methods do not help, consider increasing physical RAM or optimizing application architecture.