htop is a great replacement to top. It has... Colors! Simple keyboard shortcuts! Scroll the list using the arrow keys! Kill a process without leaving and without taking note of the PID! Mark multiple processes and kill them all!

Among all of the features, the manpage says you can press F to follow a process.

Really, you should try htop. I never started top again, after the first time I used htop.

Display a single process:

htop -p PID

psrecord

The following addresses history graph of some sort. Python psrecord package does exactly this.

pip install psrecord                             # local user install

sudo apt-get install python-matplotlib python-tk # for plotting; or via pip

For single process it's the following (stopped by Ctrl+C):

psrecord $(pgrep proc-name1) --interval 1 --plot plot1.png

For several processes the following script is helpful to synchronise the charts:

#!/bin/bash    

psrecord $(pgrep proc-name1) --interval 1 --duration 60 --plot plot1.png &

P1=$!

psrecord $(pgrep proc-name2) --interval 1 --duration 60 --plot plot2.png &

P2=$!

wait $P1 $P2

echo 'Done'

Charts look like:

memory_profiler

The package provides RSS-only sampling (plus some Python-specific options). It can also record process with its children processes (see mprof --help).

pip install memory_profiler

mprof run /path/to/executable

mprof plot

By default this pops up a Tkinter-based (python-tk may be needed) chart explorer which can be exported:

graphite-stack & statsd

It may seem an overkill for a simple one-off test, but for something like a several-day debugging it's, for sure, reasonable. A handy all-in-one raintank/graphite-stack (from Grafana's authors) image and psutil and statsd client. procmon.py provides an implementation.

$ docker run --rm -p 8080:3000 -p 8125:8125/udp raintank/graphite-stack

Then in another terminal, after starting target process:

$ sudo apt-get install python-statsd python-psutil # or via pip

$ python procmon.py -s localhost -f chromium -r 'chromium.*'

Then opening Grafana at http://localhost:8080, authentication as admin:admin, setting up datasource https://localhost, you can plot a chart like:

graphite-stack & telegraf

Instead of Python script sending the metrics to Statsd, telegraf (and procstat input plugin) can be used to send the metrics to Graphite directly.

Minimal telegraf configuration looks like:

[agent]

  interval = "1s"



[[outputs.graphite]]

  servers = ["localhost:2003"]

  prefix = "testprfx"



[[inputs.procstat]]

  pid_file = "/path/to/file/with.pid"

Then run line telegraf --config minconf.conf. Grafana part is the same, except metrics names.

sysdig

sysdig (available in Debian and Ubuntu's repos) with sysdig-inspect UI look very promising, providing extremely fine-grained details along with CPU utilisation and RSS, but unfortunately the UI is unable to render them, and sysdig can't filter procinfo event by process at the time of writing. Though, this should be possible with a custom chisel (an sysdig extension written in Lua).

To use that information on a script you can do this:

calcPercCpu.sh

#!/bin/bash

nPid=$1;

nTimes=10; # customize it

delay=0.1; # customize it

strCalc=`top -d $delay -b -n $nTimes -p $nPid 

  |grep $nPid 

  |sed -r -e "s;ss*; ;g" -e "s;^ *;;" 

  |cut -d' ' -f9 

  |tr 'n' '+' 

  |sed -r -e "s;(.*)[+]$;1;" -e "s/.*/scale=2;(&)/$nTimes/"`;

nPercCpu=`echo "$strCalc" |bc -l`

echo $nPercCpu

use like: calcPercCpu.sh 1234 where 1234 is the pid

For the specified $nPid, it will measure the average of 10 snapshots of the cpu usage in a whole of 1 second (delay of 0.1s each * nTimes=10); that provides a good and fast accurate result of what is happening in the very moment.

Tweak the variables to your needs.

I normally use following two :

1. HP caliper : its very good tool for monitoring processes it you can check call graph and other low level information also. But please note its free only for personal use.




2. daemontools : a collection of tools for managing UNIX services

If you know process name you can use

top -p $(pidof <process_name>)

If you need the averages for a period of time of a specific process, try the accumulative -c option of top:

top -c a -pid PID

"-c a" found in top for Mac 10.8.5.

For Scientific Linux, the option is -S, that can be set interactively.

If you have a cut-down Linux distribution where top does not have per process (-p) option or related options, you can parse the output of the top command for your process name to get the CPU usage information per process.

while true;  do top -bn1 | awk '/your_process_name/ {print  $8}' ; sleep 1; done

8 represents the CPU usage per process in the output of the top command in my embedded Linux distribution