Introduction
Monitoring system processes is a critical skill for Linux users and system administrators. Understanding what processes are running and how they consume resources allows you to maintain system stability and performance.
In this lab, you will learn how to use the top command, a powerful tool for real-time monitoring of Linux system processes. The top command provides detailed information about CPU usage, memory consumption, and other important system metrics. By mastering this essential command, you will be able to identify resource-intensive processes and effectively manage your Linux system resources.
Introduction to the top Command
The top command is a fundamental Linux utility that displays a dynamic, real-time view of the processes running on your system. The name "top" refers to its default behavior of showing the "top" CPU-consuming processes.
Let's start by navigating to your project directory and exploring the basic usage of the top command:
cd ~/project
Now, run the top command:
top
When you execute this command, you should see an interactive display similar to the following:
top - 14:25:30 up 2 days, 3:45, 1 user, load average: 0.15, 0.20, 0.25
Tasks: 105 total, 1 running, 104 sleeping, 0 stopped, 0 zombie
%Cpu(s): 2.0 us, 1.0 sy, 0.0 ni, 97.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
MiB Mem : 4096.0 total, 2841.3 free, 845.2 used, 409.5 buff/cache
MiB Swap: 2048.0 total, 2048.0 free, 0.0 used. 2970.5 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1234 labex 20 0 562340 42340 28456 S 2.0 1.0 0:30.25 firefox
2345 labex 20 0 78912 23456 13204 S 0.7 0.6 0:12.34 terminal
3456 root 20 0 43528 5424 4356 S 0.3 0.1 0:05.67 sshd
... (more processes)
The top display consists of two main sections:
Summary Area (top 5 lines): Provides system-wide information including:
- System uptime and load averages
- Task statistics (total, running, sleeping, etc.)
- CPU usage percentages
- Memory usage (RAM and Swap)
Process List (table below summary): Lists running processes with details such as:
- PID: Process ID
- USER: The owner of the process
- PR: Priority
- NI: Nice value
- VIRT: Virtual memory used
- RES: Resident memory used
- %CPU: CPU usage percentage
- %MEM: Memory usage percentage
- COMMAND: Command name
The display automatically refreshes every 3 seconds by default. To exit the top command, simply press the q key.
Now, let's capture a static snapshot of the processes using the -n 1 option. This tells top to update only once and then exit:
top -n 1 > ~/project/top_snapshot.txt
This command creates a file named top_snapshot.txt in your project directory containing a snapshot of the current system processes. Let's verify the file contents:
cat ~/project/top_snapshot.txt
You should see output similar to what was displayed in the interactive top session, but as a static text file.
Interpreting the top Output
Now that you have a snapshot of the system processes, let's analyze the information to understand what it tells us about the system's resource usage.
Open the top_snapshot.txt file using the nano text editor:
nano ~/project/top_snapshot.txt
In this file, you can see the same information as displayed in the interactive top command. Let's focus on identifying the most CPU-intensive process from the list.
Look at the process list section (below the summary area) and find the process with the highest value in the %CPU column. This indicates the process that was consuming the most CPU at the time the snapshot was taken.
For example, if you see a line like this:
1234 labex 20 0 562340 42340 28456 S 2.0 1.0 0:30.25 firefox
This shows that process with PID 1234 (firefox) owned by user "labex" was using 2.0% of CPU and 1.0% of memory.
Take note of the following information for the process with the highest CPU usage:
- PID (Process ID)
- USER (the owner of the process)
- %CPU (CPU usage percentage)
- %MEM (Memory usage percentage)
- COMMAND (The command or program running)
To exit nano, press Ctrl+X.
Now, create a file named top_analysis.txt to document your findings:
echo "Most CPU-intensive process analysis" > ~/project/top_analysis.txt
Add the details of the most CPU-intensive process to the file. Replace the placeholders with the actual values you observed:
echo "PID: [Replace with PID]" >> ~/project/top_analysis.txt
echo "USER: [Replace with USER]" >> ~/project/top_analysis.txt
echo "CPU%: [Replace with %CPU]" >> ~/project/top_analysis.txt
echo "MEM%: [Replace with %MEM]" >> ~/project/top_analysis.txt
echo "COMMAND: [Replace with COMMAND]" >> ~/project/top_analysis.txt
For example, if process 1234 (firefox) was the most CPU-intensive, you would enter:
echo "PID: 1234" >> ~/project/top_analysis.txt
echo "USER: labex" >> ~/project/top_analysis.txt
echo "CPU%: 2.0" >> ~/project/top_analysis.txt
echo "MEM%: 1.0" >> ~/project/top_analysis.txt
echo "COMMAND: firefox" >> ~/project/top_analysis.txt
Let's verify what we've written to the file:
cat ~/project/top_analysis.txt
This should display the contents of your analysis file with the details of the most CPU-intensive process.
Sorting and Filtering Processes in top
The top command becomes even more powerful when you learn how to sort and filter processes. In this step, you'll learn how to customize the top display to focus on specific information.
First, let's run the interactive top command again:
top
While top is running, you can use keyboard shortcuts to modify its behavior:
- Press
M(uppercase) to sort processes by memory usage - Press
P(uppercase) to sort processes by CPU usage (default) - Press
T(uppercase) to sort processes by time (how long they've been running) - Press
N(uppercase) to sort processes by PID (process ID)
Try each of these sorting options to see how the process list changes. When you're done experimenting, press q to exit top.
Now, let's create a snapshot of processes sorted by memory usage. We'll use the batch mode of top with specific options:
top -b -n 1 -o %MEM > ~/project/top_sorted_by_mem.txt
This command uses:
-b: Batch mode (non-interactive)-n 1: Run only one iteration-o %MEM: Sort by memory usage
Let's check the contents of this file:
cat ~/project/top_sorted_by_mem.txt
You should see the processes listed in order of memory usage, with the highest memory-consuming processes at the top.
Next, let's filter processes to show only those belonging to your user account:
top -b -n 1 -u labex > ~/project/top_user_filtered.txt
The -u labex option filters the output to show only processes owned by the user "labex". Let's examine this file:
cat ~/project/top_user_filtered.txt
This file should only show processes owned by the "labex" user.
Finally, let's combine sorting and filtering to create a more specific view:
top -b -n 1 -u labex -o %CPU > ~/project/top_custom.txt
This command shows only processes belonging to the user "labex" and sorts them by CPU usage. Let's check the result:
cat ~/project/top_custom.txt
These customization options make top a versatile tool for focusing on specific aspects of system performance and resource usage.
Summary
In this lab, you have learned how to use the top command to monitor and analyze processes in Linux. The skills you've acquired include:
- Running the
topcommand to view a real-time display of system processes - Understanding the information displayed in the
topoutput, including CPU usage, memory usage, and process details - Capturing snapshots of process information for analysis
- Identifying resource-intensive processes by examining CPU and memory usage
- Customizing the
topdisplay through sorting and filtering options
These skills are essential for system administration and performance monitoring in Linux environments. The top command is one of the most frequently used tools for quickly assessing system health and identifying potential performance issues.
By mastering the top command, you now have the ability to effectively monitor system resources, identify processes that may be causing performance problems, and gather the information needed to optimize system performance.
