How to Benchmark a Raspberry Pi Using Vcgencmd

The vcgencmd has been buried deep in Raspberry Pi OS for many years, but it took the Raspberry Pi 5 for us to truly learn to love it. At its most basic level, the command is used to output information from the VideoCore GPU, which forms part of the SoC. But with a few extra options / arguments we can get live CPU temperature data, voltages, clock speeds for many different components and much more. 

In this how to we will introduce the basic usage of the command and then write a custom Bash script which will benchmark any Raspberry Pi system.

Basic Usage of Vcgencmd

The command has multiple options to measure clock speeds, temperatures, voltages etc. Let's go through them and see how each command is used, and an example of its output.

Measure Clock Speeds

Every computer has more than one clock speed. The CPU may be running in the Gigahertz, but some parts of your computer will be running at much lower speeds. The vcgencmd command has options to monitor

Measure Voltages

Using vcgencmd, we can measure the voltages of the VideoCore chip, RAM and the voltages, currents in use on the many power sources, including the Power Management IC (PMIC).

System Throttle Status

When the Raspberry Pi hits around 80 degrees Celsius, it will enter thermal throttle. This reduces the speed of the CPU in an attempt to keep it cool. When running benchmarks we need to know if a CPU is throttled, and vcgencmd has the command to tell us that.

System Throttle Status Bit Table

System Configuration Info with Vcgencmd

The vcgencmd can be used to inspect and dump the current system configuration. By default, the output is directed to the standard output (the terminal) but using a pipe the output can be redirected to a file for comparison.

A Simple Benchmarking Script with Vcgencmd

With our knowledge of vcgencmd and Bash scripting we can make a simple benchmarking tool that will take a CPU temperature, speed and throttle status reading every 60 seconds and then store the details in a CSV file. 

The script is split into three sections. A 60-second idle temperature reading which gives a baseline to reference from. The second part is the stress test itself, using stress to push all four cores for five minutes. Finally we repeat the idle period for 60-seconds to show the CPU cooling down.

We’re going to write this script on a Raspberry Pi 5, but the same script will work on all models of Raspberry Pi.

1. Open a terminal and update the software repositories and then install stress. Stress is a command line tool to stress test CPUs.

sudo apt update && sudo apt install stress

2. From the main Raspberry Pi desktop menu select Programing >> Geany. Geany is a great and lightweight text editor for coding.

3. Tell the script where to find the system shell. This has the name “shabang” a concatenation of sharp (#) and bang (!).

#!/bin/bash

4. Output a message to the shell, informing the user of what the application will do. Then create a variable to store the name of the output file. This should be a CSV file, but the name can be your choosing.

echo "Tom's Hardware Benchmark Tool"
output_file="benchmark.csv"

5. Create a header for the CSV file and write to the file. This will set the column headings in the CSV file and spreadsheet.

echo "Timestamp,CPU Temperature (°C),CPU Clock Speed (MHz),CPU Throttled" > "$output_file"

6. Output a message to say that the application will idle for 60 seconds.

echo "Idle data for 60 seconds"

7. Create a for loop that will iterate 60 times.

for i in {1..60}; do

8. Write the current time to a variable, then print the timestamp to the shell.

   timestamp=$(date +"%Y-%m-%d %H:%M:%S")
   echo "$timestamp"

9. Use vcgencmd to get the current CPU temperature, cut out any information except for the temperature and save to a variable. Then echo the temperature to the shell. If we don’t do this then we will have to sanitize the data in the CSV file, but right now we can automate its removal.

   cpu_temp=$(vcgencmd measure_temp | cut -d= -f2 | cut -d\' -f1)
   echo "$cpu_temp"

10. Using vcgencmd, get the current CPU speed in MHz, save it to a variable and then print the speed to the shell. We have to slice the speed from the output of the command and then divide by 1.000,000 to get the speed in MHz.

   cpu_clock_speed=$(($(vcgencmd measure_clock arm | awk -F= '{print $2}') / 1000000))
   echo "$cpu_clock_speed"

11. Check if the CPU has been throttled, save the data to a variable and print to the shell. This will return a bit pattern, please refer to the table to decode.

   throttled_status=$(vcgencmd get_throttled)
   echo "$throttled_status"

12. Echo a series of # to the shell. This will help break the data into sections when it prints across the terminal window.

   echo "################"

13. Write the data to the CSV file. Note that we use >> to append the data to the CSV file. If there were only a single > it would be overwritten.

   echo "$timestamp,$cpu_temp,$cpu_clock_speed,$throttled_status" >> "$output_file"

14. Still inside the for loop, pause for one second and then close the for loop. The code in the for loop will write 60 readings to the CSV file, one per second of the idle time.

   sleep 1
done

15. Call the stress command to run a stress test on all four CPU cores for 300 seconds (five minutes). The “&” will place the command in the background and not block our script from running.

stress --cpu 4 -t 300 &

16. Echo (print) a message to say that the stress test is now starting.

echo "Stress data for 300 seconds"

17. We repeat the for loop from before, simply change the 60 to 300 and then record the same temperature, CPU speed and throttle status to the variables and then write to the CSV file.

for i in {1..300}; do
   timestamp=$(date +"%Y-%m-%d %H:%M:%S")
   echo "$timestamp"
   cpu_temp=$(vcgencmd measure_temp | cut -d= -f2 | cut -d\' -f1)
   echo "$cpu_temp"
   cpu_clock_speed=$(($(vcgencmd measure_clock arm | awk -F= '{print $2}') / 1000000))
   echo "$cpu_clock_speed"
   throttled_status=$(vcgencmd get_throttled)
   echo "$throttled_status"
   echo "################"
   echo "$timestamp,$cpu_temp,$cpu_clock_speed,$throttled_status" >> "$output_file"
   # Sleep for 1 second
   sleep 1
done

18. The final section is a cool down period, allowing the CPU to go back to normal. This is the same loop as the idle period.

echo "Cool down data for 60 seconds"
for i in {1..60}; do
   # Get current timestamp
   timestamp=$(date +"%Y-%m-%d %H:%M:%S")
   echo "$timestamp"
   # Get CPU temperature in degrees Celsius
   cpu_temp=$(vcgencmd measure_temp | cut -d= -f2 | cut -d\' -f1)
   echo "$cpu_temp"
   # Get CPU clock speed in MHz
   cpu_clock_speed=$(($(vcgencmd measure_clock arm | awk -F= '{print $2}') / 1000000))
   echo "$cpu_clock_speed"
   # Check if the CPU is throttled
   throttled_status=$(vcgencmd get_throttled)
   echo "$throttled_status"
   echo "################"
   # Append data to CSV file
   echo "$timestamp,$cpu_temp,$cpu_clock_speed,$throttled_status" >> "$output_file"
   # Sleep for 1 second
   sleep 1
done

19. Save the code as benchmark.sh to your home directory.

20. In a terminal, make the file executable.

chmod +x benchmark.sh

21. From the terminal, run the code and wait for the benchmark to complete.

./benchmark.sh

22. Import the CSV file into a spreadsheet and use it to produce graphs / tables of your findings.

Image 1 of 3

Complete Code Listing

#!/bin/bash
echo "Tom's Hardware Benchmark Tool"
output_file="benchmark.csv"


echo "Timestamp,CPU Temperature (°C),CPU Clock Speed (MHz),CPU Throttled" > "$output_file"
echo "Idle data for 60 seconds"
for i in {1..60}; do
    timestamp=$(date +"%Y-%m-%d %H:%M:%S")
    echo "$timestamp"
    cpu_temp=$(vcgencmd measure_temp | cut -d= -f2 | cut -d\' -f1)
    echo "$cpu_temp"
    cpu_clock_speed=$(($(vcgencmd measure_clock arm | awk -F= '{print $2}') / 1000000))
    echo "$cpu_clock_speed"
    throttled_status=$(vcgencmd get_throttled)
    echo "$throttled_status"
    echo "################"
    echo "$timestamp,$cpu_temp,$cpu_clock_speed,$throttled_status" >> "$output_file"

    # Sleep for 1 second
    sleep 1
done
stress --cpu 4 -t 300 &

echo "Stress data for 300 seconds"
for i in {1..300}; do
    timestamp=$(date +"%Y-%m-%d %H:%M:%S")
    echo "$timestamp"
    cpu_temp=$(vcgencmd measure_temp | cut -d= -f2 | cut -d\' -f1)
    echo "$cpu_temp"
    cpu_clock_speed=$(($(vcgencmd measure_clock arm | awk -F= '{print $2}') / 1000000))
    echo "$cpu_clock_speed"
    throttled_status=$(vcgencmd get_throttled)
    echo "$throttled_status"
    echo "################"
    echo "$timestamp,$cpu_temp,$cpu_clock_speed,$throttled_status" >> "$output_file"

    # Sleep for 1 second
    sleep 1
done

echo "Stress test complete, 60 second cool down period"

echo "Cool down data for 60 seconds"
for i in {1..60}; do
    timestamp=$(date +"%Y-%m-%d %H:%M:%S")
    echo "$timestamp"
    cpu_temp=$(vcgencmd measure_temp | cut -d= -f2 | cut -d\' -f1)
    echo "$cpu_temp"
    cpu_clock_speed=$(($(vcgencmd measure_clock arm | awk -F= '{print $2}') / 1000000))
    echo "$cpu_clock_speed"
    throttled_status=$(vcgencmd get_throttled)
    echo "$throttled_status"
    echo "################"
    echo "$timestamp,$cpu_temp,$cpu_clock_speed,$throttled_status" >> "$output_file"

    # Sleep for 1 second
    sleep 1
done