Linux pmap Command with Practical Examples

Introduction

In this lab, we will explore the Linux pmap command, a powerful tool for analyzing the memory usage of running processes. The lab will cover understanding the pmap command, analyzing memory usage of a process, and identifying potential memory leaks. The pmap command provides a detailed breakdown of the memory segments used by a process, including the starting address, size, permissions, and associated files or libraries. This information can be invaluable for optimizing application performance and identifying memory-related issues. The lab will guide you through practical examples and use cases for the pmap command, helping you develop essential system monitoring and management skills.

Linux Commands Cheat Sheet

Skills Graph

Understanding the pmap Command

In this step, we will explore the pmap command, a powerful tool in Linux that provides detailed information about the memory usage of a running process. The pmap command is particularly useful for identifying memory leaks and understanding the memory footprint of your applications.

Let's start by running the pmap command on a running process. We'll use the top command to find the process ID (PID) of a process we want to analyze:

top

Example output:

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
 1234 labex     20   0  124.3m  12.3m   3.4m S   0.3   0.6   0:00.12 nginx

In this example, the PID of the nginx process is 1234. We can now use the pmap command to analyze the memory usage of this process:

sudo pmap 1234

Example output:

1234:   nginx: nginx worker process
0000562a0f4f3000      4K r-x-- /usr/sbin/nginx
0000562a0f6f4000    132K r---- /usr/sbin/nginx
0000562a0f6ff000     16K rw--- /usr/sbin/nginx
0000562a0f703000     12K rw---   [ anon ]
0000562a0f706000   2044K r-x-- /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0f908000   2048K ----- /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0fb08000     16K r---- /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0fb0c000      8K rw--- /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0fb0e000     20K rw---   [ anon ]
0000562a0fb13000    132K r-x-- /lib/x86_64-linux-gnu/ld-2.35.so
0000562a0fd2c000     12K r---- /lib/x86_64-linux-gnu/ld-2.35.so
0000562a0fd2f000      4K rw--- /lib/x86_64-linux-gnu/ld-2.35.so
0000562a0fd30000      4K rw---   [ anon ]
total            4,436K

The pmap command provides a detailed breakdown of the memory usage of the specified process. Each line represents a memory segment, with information about the starting address, size, permissions, and the file or library associated with that segment.

This output can help you understand the memory usage of your application, identify potential memory leaks, and optimize its performance.

Analyzing Memory Usage of a Process

In this step, we will dive deeper into analyzing the memory usage of a process using the pmap command. We'll explore different options and techniques to gain a comprehensive understanding of how a process is utilizing system memory.

Let's start by running the pmap command with the -x option, which provides more detailed information about the memory segments used by the process:

sudo pmap -x 1234

Example output:

1234:   nginx: nginx worker process
Address   Kbytes Mode  Offset           Device     Mapping
0000562a0f4f3000      4     r-x--    0000000000000000 /usr/sbin/nginx
0000562a0f6f4000    132     r----   0000000000001000 /usr/sbin/nginx
0000562a0f6ff000     16     rw---   0000000000002000 /usr/sbin/nginx
0000562a0f703000     12     rw---                [ anon ]
0000562a0f706000   2044     r-x--   0000000000000000 /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0f908000   2048     -----   0000000000202000 /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0fb08000     16     r----   0000000000202000 /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0fb0c000      8     rw---   0000000000204000 /lib/x86_64-linux-gnu/libc-2.35.so
0000562a0fb0e000     20     rw---                [ anon ]
0000562a0fb13000    132     r-x--   0000000000000000 /lib/x86_64-linux-gnu/ld-2.35.so
0000562a0fd2c000     12     r----   0000000000019000 /lib/x86_64-linux-gnu/ld-2.35.so
0000562a0fd2f000      4     rw---   000000000001b000 /lib/x86_64-linux-gnu/ld-2.35.so
0000562a0fd30000      4     rw---                [ anon ]
total            4,436

The additional information provided by the -x option includes the memory mode (read, write, execute), the offset within the mapped file, the device number, and the name of the mapped file or library.

You can also use the pmap command with the -d option to display the dynamic memory segments used by the process:

sudo pmap -d 1234

Example output:

1234:   nginx: nginx worker process
Address   Kbytes Mode  Offset           Device     Mapping
0000562a0f703000     12     rw---                [ anon ]
0000562a0fb0e000     20     rw---                [ anon ]
0000562a0fd30000      4     rw---                [ anon ]
total                36

The -d option shows the anonymous memory segments, which are dynamically allocated by the process and not associated with any specific file or library.

These pmap command options can help you identify the memory usage patterns of your application, detect potential memory leaks, and optimize its performance.

Identifying Memory Leaks with pmap

In this final step, we will learn how to use the pmap command to identify potential memory leaks in a running process. Memory leaks can lead to excessive memory consumption and performance issues, so it's important to be able to detect and address them.

Let's start by running a simple Python script that simulates a memory leak:

cat << EOF > leak.py
import time

def leak():
    x = []
    while True:
        x.append([0] * 1000000)
        time.sleep(1)

if __name__ == "__main__":
    leak()
EOF

python3 leak.py &

This script continuously allocates large arrays, which will eventually lead to a memory leak. Let's use the pmap command to monitor the memory usage of this process:

sudo pmap -x $(pgrep -f leak.py)

Example output (after a few minutes):

18768:   python3 leak.py
Address   Kbytes Mode  Offset           Device     Mapping
00005612b3a4f000      4     r-x--    0000000000000000 /usr/bin/python3.10
00005612b3c50000   1028     r----   0000000000001000 /usr/bin/python3.10
00005612b3d54000    408     rw---   0000000000002000 /usr/bin/python3.10
00005612b3e7c000    144     rw---                [ anon ]
00005612b3ea0000   2048     r-x--   0000000000000000 /lib/x86_64-linux-gnu/libc-2.35.so
00005612b40a0000   2048     -----   0000000000200000 /lib/x86_64-linux-gnu/libc-2.35.so
00005612b42a0000     16     r----   0000000000200000 /lib/x86_64-linux-gnu/libc-2.35.so
00005612b42a4000      8     rw---   0000000000202000 /lib/x86_64-linux-gnu/libc-2.35.so
00005612b42a6000     20     rw---                [ anon ]
00005612b42ab000    132     r-x--   0000000000000000 /lib/x86_64-linux-gnu/ld-2.35.so
00005612b44c4000     12     r----   0000000000019000 /lib/x86_64-linux-gnu/ld-2.35.so
00005612b44c7000      4     rw---   000000000001b000 /lib/x86_64-linux-gnu/ld-2.35.so
00005612b44c8000      4     rw---                [ anon ]
00005612b44c9000 1048576     rw---                [ anon ]
total           1,054,448

As you can see, the memory usage of the Python process keeps increasing over time, indicating a potential memory leak. The pmap command shows that the process is allocating a large amount of anonymous memory, which is a clear sign of a memory leak.

To confirm the memory leak, you can run the pmap command periodically and observe the growth in the "total" memory usage.

Summary

In this lab, we explored the Linux pmap command, which provides detailed information about the memory usage of a running process. We learned how to use the pmap command to analyze the memory usage of a process, including identifying the memory segments, their sizes, and the associated files or libraries. This information can be valuable for understanding the memory footprint of your applications and identifying potential memory leaks.

Additionally, we discussed how the pmap command can be used to identify memory leaks in your applications. By regularly monitoring the memory usage of your processes using pmap, you can detect any unexpected increases in memory usage, which may indicate a memory leak. This can help you troubleshoot and resolve performance issues in your applications.

Linux Commands Cheat Sheet