Measure script execution time using `trap '' DEBUG` and `$BASH_COMMAND`

How to Measure Script Execution Time Using `trap '...' DEBUG` and `$BASH_COMMAND` in Bash

Introduction

In Linux system programming and scripting, understanding how long your script or a particular part of your script takes to execute can provide critical insights, whether for optimization, debugging, or just curiosity. While there are traditional methods like time and date for simple cases, these might not suffice when you want to track the performance of individual commands within a script. This is where Bash's trap '...' DEBUG and the $BASH_COMMAND variable come into play.

Q: What is the `trap` command in Bash, and how is it used?

A: The trap command in Bash is used to specify a script or command that will be executed when a signal or a specific event occurs in a script. Using trap with the DEBUG signal allows you to run a specific command before every command in a script executes.

Q: What does `$BASH_COMMAND` do in the context of Bash Scripts?

A: $BASH_COMMAND is a special variable in Bash that holds the current command to be executed. This is exceptionally useful when combined with a trap on DEBUG because it lets you see or log the exact command that is about to run.

Q: How can these be used to measure the execution time of commands in a script?

A: By setting a trap with a DEBUG argument, you can execute a custom function just before each command in your script runs. In this function, you can record the time before the command executes, and after it completes, calculate the time taken using $BASH_COMMAND to keep track of which command was executed.

Background and Examples

The mechanism provided by trap '...' DEBUG and $BASH_COMMAND can be exploited for more detailed performance tracking in scripts. Here's a simple way of how you can set this up:

Simple Example:

#!/bin/bash

function before_command {
    start_time=$(date +%s%N)
}

function after_command {
    local duration=$((($(date +%s%N) - $start_time)/1000000))
    echo "Execution time for '$BASH_COMMAND': ${duration}ms"
}

trap 'before_command' DEBUG
trap 'after_command' EXIT

# Example command
ls -l

In this script: 1. before_command is a function that records the time just before a command runs. 2. after_command calculates and prints the time taken by the last command before the script exits. 3. trap 'before_command' DEBUG sets up before_command to be called before every command. 4. The trap 'after_command' EXIT ensures that the after_command function is called upon script completion to log the time of the last command.

Advanced Example Script:

#!/bin/bash

declare -A cmd_start_times

function time_command_start {
    cmd_start_times["$BASH_COMMAND"]=$(date +%s%N)
}

function time_command_end {
    local start_time=${cmd_start_times["$BASH_COMMAND"]}
    local end_time=$(date +%s%N)
    local duration=$(( (end_time - start_time)/1000000 ))
    echo "Execution Time for '$BASH_COMMAND': ${duration}ms"
}

trap 'time_command_start' DEBUG
trap 'time_command_end' EXIT

# Multiple example commands
sleep 1
ls -lh
sleep 2
echo "Hello, World!"
date

This script tracks the execution time of each command more comprehensively. Here, when each command starts, the start time is recorded with the command text as the key in an associative array. When the script exits, it calculates the duration for the last command and outputs it.

Conclusion

trap '...' DEBUG in conjunction with $BASH_COMMAND offers a powerful, fine-grained approach to measuring execution times of commands within Bash scripts. This can significantly aid in performance tuning and debugging complex scripts. Though it might add some overhead due to the frequent function calls, for most diagnostic purposes, this is a trade-off worth making for the depth of insight gained into the script's behavior.

How to Measure Script Execution Time Using trap '...' DEBUG and $BASH_COMMAND in Bash

Introduction

Q: What is the trap command in Bash, and how is it used?

Q: What does $BASH_COMMAND do in the context of Bash Scripts?