How to Measure Program Execution Time in the Linux Shell

When running commands or scripts in the Linux shell, it’s often useful to know how long they take to execute, especially when optimizing or testing under different conditions. Here are several ways to measure execution time in Bash, from basic to more advanced methods.

1. Using the time Command

The simplest way to measure execution time is with the built-in time command, which outputs real, user, and system time taken by a command.

time sleep 2

Output:

real    0m2.002s
user    0m0.000s
sys     0m0.002s

• Real time is the total elapsed time.
• User time is the CPU time spent in user-mode.
• Sys time is the CPU time spent in kernel-mode.

2. Getting Detailed Timing with /usr/bin/time

For more detailed timing information, use the external /usr/bin/time command with the -v flag (available in GNU Time), which provides insights like memory usage, page faults, and context switches.

/usr/bin/time -v sleep 1

This provides comprehensive details on the command’s performance, which can be useful for in-depth analysis beyond just execution time.

3. Using $SECONDS for Basic Timing

Bash has a special variable, $SECONDS, which counts the number of seconds since the shell was started. You can use it to measure execution time within a script.

SECONDS=0
# Your command here
sleep 2
echo "Execution time: $SECONDS seconds"

This is a quick and straightforward way to measure time in seconds for commands or loops within a script.

4. Using date for Higher Precision

To capture more precise timings, use date with nanosecond precision. This approach involves taking a timestamp before and after execution and then calculating the difference.

start=$(date +%s.%N)
# Your command here
sleep 0.5
end=$(date +%s.%N)
duration=$(echo "$end - $start" | bc)
printf "Execution time: %.6f seconds\n" "$duration"

This method provides timing with millisecond or microsecond precision, depending on the system.

5. Timing Multiple Commands with { } or ( )

To time a series of commands, you can group them with { } or ( ) and use time on the entire block.

• Same shell: Use { } to run commands in the same shell context.

  time {
    echo "Starting command block"
    sleep 1
    echo "Ending command block"
  }
  

• Subshell: Use ( ) to run commands in a subshell.

  time (
    echo "Starting subshell command block"
    sleep 1
    echo "Ending subshell command block"
  )
  

The choice depends on whether you need variables or environment settings to persist across commands.

6. Using Custom Functions for Reusability

If you frequently need to measure execution time, you can create a function to simplify the process.

function measure_time() {
    local start=$(date +%s.%N)
    "$@"
    local end=$(date +%s.%N)
    local duration=$(echo "$end - $start" | bc)
    printf "Execution time: %.6f seconds\n" "$duration"
}

# Usage
measure_time sleep 1

With this function, simply call measure_time followed by any command to get its execution time.

7. For Line-by-Line Timings: Using gnomon

For detailed line-by-line timings, consider using gnomon, a command-line utility that prepends timestamp information to each line of output from another command.

Install gnomon with:

npm install -g gnomon

Then use it as follows:

your_command | gnomon --medium=1.0 --high=4.0 --ignore-blank --real-time=100

This tool highlights lines that exceed a certain threshold, making it useful for identifying slow parts in long-running processes.

Whether you’re running a single command or timing multiple commands, Linux offers a variety of ways to measure execution time:

• Use time for simple execution time tracking.
• /usr/bin/time -v for detailed system statistics.
• $SECONDS for basic timing in scripts.
• date for high precision.
• gnomon for line-by-line timing.

Each method has its strengths, so choose the one that best fits your needs based on the level of precision and detail you require.