memusg -- Measure memory usage of processes

memusg

#!/usr/bin/env bash
# memusg -- Measure memory usage of processes
# Usage: memusg COMMAND [ARGS]...
#
# Author: Jaeho Shin <netj@sparcs.org>
# Created: 2010-08-16
############################################################################
# Copyright 2010 Jaeho Shin.                                               #
#                                                                          #
# Licensed under the Apache License, Version 2.0 (the "License");          #
# you may not use this file except in compliance with the License.         #
# You may obtain a copy of the License at                                  #
#                                                                          #
#     http://www.apache.org/licenses/LICENSE-2.0                           #
#                                                                          #
# Unless required by applicable law or agreed to in writing, software      #
# distributed under the License is distributed on an "AS IS" BASIS,        #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and      #
# limitations under the License.                                           #
############################################################################
set -um

# check input
[[ $# -gt 0 ]] || { sed -n '2,/^#$/ s/^# //p' <"$0"; exit 1; }

# TODO support more options: peak, footprint, sampling rate, etc.

pgid=$(ps -o pgid= $$)
# make sure we're in a separate process group
if [[ "$pgid" == "$(ps -o pgid= $(ps -o ppid= $$))" ]]; then
    cmd=
    set -- "$0" "$@"
    for a; do cmd+="'${a//"'"/"'\\''"}' "; done
    exec bash -i -c "$cmd"
fi

# detect operating system and prepare measurement
case $(uname) in
    Darwin|*BSD) sizes() { /bin/ps -o rss= -g $1; } ;;
    Linux) sizes() { /bin/ps -o rss= -$1; } ;;
    *) echo "$(uname): unsupported operating system" >&2; exit 2 ;;
esac

# monitor the memory usage in the background.
(
peak=0
while sizes=$(sizes $pgid)
do
    set -- $sizes
    sample=$((${@/#/+}))
    let peak="sample > peak ? sample : peak"
    sleep 0.1
done
echo "memusg: peak=$peak" >&2
) &
monpid=$!


# run the given command
exec "$@"

Thanks for the cool tool! :-)

@bbsunchen it appears to be using the value of the RSS column from ps which, according to the man page, is measured "in 1024 byte units". But that can't be right as I'm getting usage values like 138487884 and I don't, sadly, have 138 GB or RAM.

The man page linked above can no longer be found. The unit of RSS from ps is now kb. https://man7.org/linux/man-pages/man1/ps.1.html

I tried out this script, but it didn't produce the info I wanted to capture on my M2 Max MBP. Since Apple Silicon uses unified memory and treats RAM and VRAM as the same thing, the output of ps does not match what is shown in Activity Monitor for graphically intensive apps -- for me, this is Stable Diffusion running in Python. After some experimenting, I came up with the following one-liner that works well enough for me:

footprint --noCategories --sample 0.1 -f bytes -p [PID] | awk '/[process name]/ {print $5; fflush()}' >> /[path]/memout.txt

The footprint command more accurately accounts for the full memory use of a process. --noCategories prevents the output of a breakdown of various categories of memory use that isn't of interest to me. --sample 0.1 polls the memory use every 0.1s, which is overkill for most uses and often not attainable -- footprint will dial back the polling rate automatically if it finds it can't keep up. -f bytes outputs the exact memory usage to the byte, which is important because the default formatting often only outputs two significant figures for large memory usage. And of course you need to supply the PID to monitor with -p.

The awk command further refines the output of footprint, plucking out just the line (though you need to provide the process name that footprint outputs in order for this to work; in my case it was "Python") and then the field containing the memory use number. The fflush() statement is important so that awk will output continuously rather than buffering the output until footprint quits, since if you terminate the monitoring with Ctrl-C, awk will terminate too before it can write from its buffer.

I then redirect the filtered output to a file so I can take data for as long as I want without filling up the Terminal output. Note that the output is a full history of memory use rather than just a maximum, so it works a bit differently compared to netj's script. However, you can easily import the data into Numbers or Excel for graphing and picking out the maximum yourself. You could probably easily modify the command into a short bash script that could keep track of the maximum for you (just define a variable to hold the last seen maximum value and compare its contents with each new output from footprint/awk), but I like being able to see when during process execution certain levels of memory use occurred.

Hopefully this will be helpful to someone.