How to Make the Top Command Sort by Memory Usage in Linux

As a Linux system administrator, understanding memory utilization is critical for optimizing performance and troubleshooting issues. The top command provides powerful insight into process memory usage, but it requires some configuration for the best views.

In this comprehensive 2650-word guide, we will cover:

• Background on Linux memory management
• An overview of process memory metrics
• Using top for memory analysis
• Sorting the top view by memory statistics
• Interactive sorting and filtering approaches
• Signals and display customization
• Additional references for mastering top

Linux Memory Management Essentials

Before diving into top, let‘s review some essential Linux memory concepts. This will help contextualize the memory statistics we‘re looking to analyze.

Physical RAM in Linux consists of pages, small chunks of memory around 4 KB. When a process needs memory, the kernel assigns it free pages. The three main categories for these pages are:

• Resident Memory (RES): "Real" memory actively in physical RAM. This memory is instantly available to processes.
• Shared Memory (SHR): Memory mapped into multiple processes, pointing to the same physical pages. Saving memory via sharing.
• Swapped Memory: Memory pages moved out of physical RAM onto disk. Requires paging back in to be accessed, at a performance cost.

When the system is low on free resident memory pages, the kernel starts swapping less used memory to disk. Swap space is reserved space on disk that serves as virtual memory backup. The downside is disk storage is incredibly slow compared to RAM speeds.

The goal in monitoring memory usage is to:

• Keep resident (RES) usage at a level where minimal swapping occurs
• Identify any processes with high swap usage that can be optimized

This is where utilities like top are extremely useful for analytical insights.

Top Command Process Memory Metrics

The top command shows various memory usage attributes on a per-process level:

• VIRT: Displays the total virtual memory allocated to the process. This includes all mapped files and libraries, stacks, heap, etc.
• RES: Displays the actual resident, non-swapped physical memory being used by the process.
• SHR: The shared memory of a process. Memory shared with other processes via global variables, shared libraries, etc.
• SWAP: The amount of memory swapped out to disk by this particular process.

For memory analysis, the RES and SWAP columns provide the most valuable data. RES shows total current physical memory usage, while SWAP highlights processes hitting disk the most.

Now let‘s examine how to view this data.

Launching and Understanding Top

The simplest way to launch top is:

top

This opens an interactive terminal display that updates process and system information continuously.

The very top section shows overall memory statistics:

• total: Total physical RAM
• used: RAM currently occupied
• free: Unused available RAM
• Mem: Percentage of RAM in use

Further down is the per-process data in column format:

Scanning this list, we can already detect issues like high swap usage on individual processes. But to fully analyze memory, we need to sort by the relevant metrics.

Sorting Top by Memory Usage

To view processes ranked by memory utilization rather than CPU usage, use the -o flag along with %MEM:

top -o %MEM

This orders processes taking up the most overall percentage of total RAM first:

The top consumers are immediately visible for inspection.

Similarly, we can sort by resident memory usage with -o RES, shared memory -o SHR, or swap usage with -o SWAP:

top -o RES
top -o SHR 
top -o SWAP

This reveals processes actually occupying the most physical RAM, sharing the most, or swapping the most pages to disk respectively.

For ongoing monitoring, an interactive sort is also available within the running top session using shift+M or the O (orderby) command.

Filtering Top for Specific Process Data

In addition to sorting, top supports filters to narrow down the list of processes. This assists in targeting memory investigations around users, groups, or process names.

For example, to isolate all processes for the postgres user:

top -u postgres

Or to analyze only processes with command names matching "node":

top -p $(pgrep -d , node)

Many other filters are available such as showing child processes or threads. Consult the top man pages for additional options.

Sending Signals to Processes

Beyond observational analysis, top allows interacting with processes directly using signal commands.

For instance, to terminate process ID 1234, type k then the PID followed by TERM:

k 1234 TERM

This executes a Linux kill -TERM 1234 without leaving the top interface. Other signals like HUP, INT, KILL or even custom signals are supported after the PID.

Signaling processes can be useful for stopping runaway memory consumers detected during top analysis.

Customizing the Top Display

For regular memory investigations, customizing the top display is recommended to focus on memory data.

Pressing f opens the field management menu for selecting which columns to hide or show. Fields like CPU time and other metrics unrelated to memory can disabled from view here.

The s (seconds) option alters the refresh rate. Setting this higher like 5-10 seconds smooths out spikes for steadier memory usage analysis.

Configuration changes can be saved to ~/.toprc by pressing W to persist custom displays between sessions.

Practical Examples and Usages

Now that we‘ve covered the key concepts, let‘s walk through some applied examples demonstrating using top for memory troubleshooting scenarios as a Linux system administrator:

Identifying System Memory Exhaustion

After a Linux server begins failing requests with out of memory errors, top can help identify the source:

top -o %MEM

This overview determines if memory is completely exhausted system-wide based on the free and available memory percentages.

Sorting by %MEM also quickly surfaces processes consuming an extreme portion of total RAM. Killing or restricting these may alleviate an acute shortage.

Analyzing Web Server Memory Usage

On a production Linux web server, the HTTP daemon and application processes often dominate memory.

Filtering top helps isolate their memory impact:

# Apache httpd processes
top -u httpd 

# Node.js application processes 
top -p $(pgrep -d , node)  

From here, the process displaying high swap usage are inspected. Excessive swapping suggests configuration tweaks like limiting worker processes or increasing system RAM may be necessary.

Checking Container Memory Limits

Managing groups of containers on a Linux host requires ensuring their memory limits are correctly enforced.

The top view can be filtered to check containerized processes matching names like "docker" or "kube":

top -o %MEM | grep docker

Monitoring their total and per-process resident memory use determines if limits are functioning. Any exceeding assigned limits would indicate further resource restriction is needed.

These examples demonstrate applying top‘s memory usage insights for common Linux administration tasks. Granular memory data empowers informed, data-driven decisions.

Additional Resources to Master Top

While this guide covers the key concepts for leveraging top for memory analysis, entire books have been written on its capabilities. Here are some additional resources for mastering the top command:

• Man7‘s Guide to Monitoring and Analyzing System Performance with Top – A full top chapter reference from Linux experts.
• Admin Guide to Linux top Command – Tecmint‘s extensive top usage guide with abundant examples.
• Mastering Linux Monitoring with top Video Course – Visual recordings on advanced top customization.

Additionally, always reference the official man pages for the authoritative usage documentation:

man top

Conclusion

In Linux, visible memory metrics are essential for maximizing performance. CPU usage often grabs attention, but RAM utilization and swapping indicators can uncover more subtle issues.

The interactive top utility exposes memory statistics on running processes otherwise invisible to administrators. Tapping into this data only requires some configuration—sorting and filtering—to extract the insights necessary for informed memory optimization.

Now whenever Linux memory problems arise, top possesses the answers under the hood. We simply need ask the right questions tailored to memory analysis, as demonstrated here.

Understanding these troubleshooting techniques empowers admins to plan, upgrade, tweak configurations, kill runaway processes or otherwise take action. Knowledge of memory ultimately leads to faster, less swap-burdened and more resilient Linux systems in production environments especially.