As a developer, understanding how to monitor system resources and processes is crucial for debugging issues and optimizing performance. The Linux top command is one of the most valuable tools for this task.
In this comprehensive guide, we will explore the top command in depth, covering everything you need to know to utilize it effectively in your development workflow.
An Introduction to Top
The top command provides a dynamic, real-time view of the running processes on your Linux system. It gives you key insights like:
- CPU and memory usage for processes
- Total CPU and memory usage for the system
- Uptime
- Load averages
Top presents this system information in a frequently updated textual interface. This makes it easy to monitor resource usage over time to identify processes that may be consuming excessive resources.
Some key capabilities provided by top include:
- Sorting processes by different metrics like CPU or memory usage
- Filtering processes by user, state, name, etc.
- Renicing processes to influence CPU scheduling priorities
- Getting batch/raw output for logging or further analysis
- Viewing detailed CPU time breakdowns
In the hands of a developer, top is a powerful tool for identifying performance issues caused by specific processes. Let‘s explore some examples of using top for common development tasks.
Monitoring System Resources
The top command gives you an overview of total system utilization – key metrics like CPU, memory, and load averages. For example:
top - 19:02:06 up 21:56, 1 user, load average: 0.00, 0.01, 0.05
Tasks: 296 total, 1 running, 295 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.8 us, 0.4 sy, 0.0 ni, 98.7 id, 0.1 wa, 0.0 hi, 0.0 si, 0.0 st
MiB Mem : 7893.5 total, 6887.6 free, 467.5 used, 538.4 buff/cache
MiB Swap: 2048.0 total, 2048.0 free, 0.0 used. 7044.5 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMANDThis top section provides an at-a-glance view of current utilization. As a developer, keep an eye on the load averages (1 min, 5 min, 15 min) and memory usage as indicators of overall system health.
Spikes in load averages can indicate CPU saturation. Consistently high load may mean your system is underpowered for the work required. Memory usage will show if processes are leaking memory over time.
Identifying Resource-Intensive Processes
The process table at the bottom of top is for identifying processes using high CPU and memory. By default, top sorts by %CPU usage, showing the most resource-intensive processes at the top.
Let’s say the database query load on your test server suddenly spikes. Top gives you real-time insight into which queries are responsible:
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
17248 postgres 20 0 0.227t 0.012t 10640 S 17.3 0.2 29857:49 postgres Here we see the Postgres process is consuming 17.3% CPU – indicating expensive queries are running. The TIME+ field shows the total accumulated CPU time used by the process since startup.
With this information, we can log into PostgreSQL and use built-in tools like EXPLAIN to optimize our problematic queries.
Monitoring System Health Checks
Most server applications have background health check and monitoring processes. Observing their resource usage clues you into application issues.
For example, Django web apps have background workers that process task queues. If CPU usage of these workers is consistently high, it indicates your application code has some inefficient tasks that need optimization.
Here’s an example of monitoring a Celery worker process handling Django application tasks:
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
29386 deploy 20 0 366988 14008 9396 R 17.3 0.2 0:16.74 celery worker With top, a developer gets real-time visibility into backend processes that power their application. They can identify underperforming code by correlating high CPU in workers with application logs and metrics.
Spotting Resource Leaks
Applications with memory or file descriptor leaks can be identified with top before they cause catastrophic failure.
The RES (resident memory) column shows a process‘s current physical memory usage. This will grow over time for processes with memory leaks. Sorting by RES makes these patterns clear:
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
24323 deploy 20 0 15.725g 1.404g 20132 S 10.3 18.5 17:02.40 leaky-processHere we see the leaky-process continually consumes more and more physical memory. Restarting this fixes the symptoms temporarily, but ultimately the code needs to be fixed.
Top gives developers early warning to troubleshoot and patch these types of issues.
Filtering Processes
When investigating high utilization, filtering top output by user, process name, or other criteria is useful to drill down.
Prefix the command with pidof to filter for a specific process:
# Show only Nginx worker processes
top -p $(pidof nginx)The -u flag filters by process owner – handy for checking utilization of your own processes:
# Show processes owned by user deploy
top -u deploy For more advanced filtering, press O while top is running to open the configuration screen. Here you can filter by criteria like name, state, CPU usage etc.
Interactive Commands
While top runs interactively, you can explore running processes and influence scheduling. Press H or ? in the interface for a menu of interactive commands.
Some particularly useful ones include:
R – Renice a Process – influence CPU scheduler priority
K – Kill a Process
F – Add Fields to output
o – Interactively configure filtering/sorting
So by renicing processes consuming excessive CPU, you can influence top‘s output and potentially alleviate high load issues. Killing processes as a last resort can also terminate runaway processes.
Output for Further Analysis
Top accepts various command line flags to produce output suitable for log files and external tools rather than live display.
-b – Batch mode – useful for periodic logging
-d – Custom delay between updates
-n – Max number of iterations before exiting
For example, logging overall utilization metrics with batch mode:
top -b -n1 > system_health.logThis runs top once, outputting system resource usage to a local file. By scripting this command and plotting data over time, you gain visibility into gradual resource changes.
Developers can feed this data into monitoring stacks like InfluxDB/Grafana forpretty historical dashboards!
Customizing the Display
While defaults work well for most, top has extensive customization in the interactive config brought up with shift+O.
You can show/hide columns like SWAP usage or add custom meters like page faults. The color/highlighting schema is also configurable here.
Saving customizations to ~/.toprc persists them between sessions. I recommend tinkering here to tailor top‘s output to your needs.
Capabilities by User Type
Out of the box functionality varies by the user running top:
Regular Users – View processes they own and system resource usage
Root Users – View all processes and interactively influence scheduling priority and kill processes
So while top is read-only for regular developers, root can actively troubleshoot issues with kill, renice, etc.
Alternative Tools
While top is a classic, many alternatives exist that build on its concepts:
- htop – Interactive process viewer with visual upgrades
- glances – Top-inspired overview of key system metrics
- dstat – Flexible tool to show resource usage statistics
I suggest developers experiment with these tools to find which most suits their personal workflow. Top remains quick, simple, and universal.
Conclusion
The top utility offers developers invaluable visibility into running processes and real-time system resource metrics. Mastering top is critical whether optimizing the performance of production systems or troubleshooting development environments.
Hopefully this guide has shown how top can be leveraged for common tasks like identifying CPU/memory-intensive processes, spotting leaks/failures, and influencing scheduler priority. Both reactive and proactive use cases exist.
While dashboarding solutions provide historical monitoring, they lack the dynamic interactivity of top. Used alongside other tools, top gives developers key insights to create performant, scalable systems.
