Best Stress Test and Benchmark CPU Performance Debian 12/11/10

This guide aims to demonstrate how to Stress Test and Benchmark CPU Performance Debian. This includes Debian versions such as Debian 10 Buster, Debian 11 Bullseye, and Debian 12 Bookworm.

Stress tests and benchmarks are valuable tools for evaluating the performance of desktop PCs and server CPUs. They are particularly useful for identifying hardware problems and system anomalies. Follow the steps outlined below to Stress Test and Benchmark CPU Performance Debian effectively.

Before proceeding, ensure you have access to your Debian server as a root user or a non-root user with sudo privileges. Refer to the following initial server setup guides for assistance:

Initial Server Setup with Debian 10: https://bluehoster.info/initial-server-setup-with-debian-10/
Initial Server Setup with Debian 11: https://bluehoster.info/initial-server-setup-with-debian-11/
Initial Server Setup with Debian 12 Bookworm: https://bluehoster.info/initial-server-setup-with-debian-12-bookworm/

Now, let’s delve into the steps to Stress Test and Benchmark CPU Performance Debian.

Step 1 – Benchmark CPU Performance with Sysbench on Debian

Sysbench is a versatile, scriptable, multi-threaded benchmarking tool. While commonly used for database benchmarks, it can also be used to create complex workloads that do not involve a database server.

Install Sysbench on Debian

To utilize Sysbench, it must be installed on your Debian server. Begin by updating the system package list:

sudo apt update

Next, install Sysbench using the following command:

sudo apt install sysbench -y

Start Benchmark CPU with Sysbench

With Sysbench installed, you can start benchmarking the CPU using the following command:

sysbench --test=cpu run

This command will generate a comprehensive report, similar to the one shown below:

**Output**
WARNING: the --test option is deprecated. You can pass a script name or path on the command line without any options.
sysbench 1.0.20 (using system LuaJIT 2.1.0-beta3)

Running the test with following options:
Number of threads: 1
Initializing random number generator from current time

Prime numbers limit: 10000

Initializing worker threads...

Threads started!

CPU speed:
    events per second:   703.23

**General statistics:
    total time:                          10.0017s**
    total number of events:              7036

Latency (ms):
         min:                                    1.29
         avg:                                    1.42
         max:                                   21.29
         95th percentile:                        1.67
         sum:                                 9990.21

Threads fairness:
    events (avg/stddev):           7036.0000/0.00
    execution time (avg/stddev):   9.9902/0.00

The "total time" displayed under "General statistics" is a key indicator of CPU performance.

You can also run the benchmark with multiple threads:

sysbench cpu --threads=2 run

In this output, you can observe the CPU speed, and you can evaluate your CPU performance by considering the "events per second" value.

**Output**
sysbench 1.0.20 (using system LuaJIT 2.1.0-beta3)

Running the test with following options:
Number of threads: 2
Initializing random number generator from current time

Prime numbers limit: 10000

Initializing worker threads...

Threads started!

CPU speed:
    events per second:  1331.75

General statistics:
    total time:                          10.0015s
    total number of events:              13324

Latency (ms):
         min:                                    1.26
         avg:                                    1.50
         max:                                   36.45
         95th percentile:                        1.79
         sum:                                19949.40

Threads fairness:
    events (avg/stddev):           6662.0000/103.00
    execution time (avg/stddev):   9.9747/0.02

Step 2 – How To Stress Test CPU with Stress Tool on Debian?

The Stress command-line tool can be employed to subject the CPU, memory, and disk input-output to stress tests. This is another method to Stress Test and Benchmark CPU Performance Debian.

It’s important to note that this tool doesn’t perform any benchmark tests in the conventional sense. Instead, it consistently pushes the CPU to its limits, making it operate at 100% utilization.

Note: It is advisable to close all running applications before initiating a stress test. Prolonged stress testing may lead to system crashes, potentially requiring a hard reboot for recovery.

Install stress tool on Debian

Install the stress tool on your server using the following command:

sudo apt install stress -y

Once the installation is complete, initiate the stress test with the command:

stress --cpu 2

Note: The number 2 signifies the number of threads used for performing the test.

To halt the test, either close the terminal or press Ctrl+C.

Step 3 – How To Stress Test CPU with Stress-ng on Debian?

Stress-ng is a more advanced and updated version of the stress tool.

Install stress-ng on Debian

Install stress-ng on your Debian server using the command:

sudo apt install stress-ng -y

It functions similarly to the stress tool, with the same warnings and notes applying.

Initiate the stress-ng test using the following command:

stress-ng --cpu 4

Terminate the test by closing the terminal or pressing Ctrl+C.

Step 4 – How To Monitor CPU Performance with S-tui on Debian?

S-tui is a terminal UI for monitoring your computer’s performance. It provides graphical representations of CPU temperature, frequency, power, and utilization directly within the terminal. This is a useful way to monitor while you Stress Test and Benchmark CPU Performance Debian.

Install S-tui on Debian

Install S-tui on Debian using the command:

sudo apt install s-tui stress

Note: S-tui is essentially a terminal-based frontend for the Stress command-line app. Be mindful of potential system lockups during high CPU usage.

Start the stress test using S-tui by running:

s-tui

[Image of s-tui interface showing CPU stats]

Terminate the test by pressing Ctrl+C or closing the terminal.

Conclusion

This guide has covered the usage of sysbench, stress, stress-ng, and s-tui tools to Stress Test and Benchmark CPU Performance Debian. You can readily install these tools on your server and begin testing and benchmarking your CPU performance.

We hope you found this helpful.

Alternative Solutions for Stress Testing and Benchmarking CPU Performance on Debian

While the methods described above are effective, here are two alternative approaches to stress testing and benchmarking CPU performance on Debian systems:

1. Using Phoronix Test Suite:

The Phoronix Test Suite is a comprehensive benchmarking platform that automates the process of running a wide range of tests. It provides a standardized and repeatable environment for evaluating system performance.

Explanation: Phoronix Test Suite manages test dependencies, automates execution, and provides detailed reporting with performance metrics. It includes various CPU-specific benchmarks like 7-Zip compression, x264 video encoding, and more. This suite simplifies the process and allows for standardized comparisons across different systems.
Installation:
```
sudo apt install phoronix-test-suite
```
Usage Example:
To run a specific CPU-intensive benchmark, such as the 7-Zip compression test, use the following command:
```
phoronix-test-suite benchmark 7-zip
```
The Phoronix Test Suite will download, install, run the benchmark, and present the results in a clear and concise manner. You can explore other CPU-related benchmarks within the suite using the phoronix-test-suite list-tests command.

2. Leveraging Docker and Specific CPU-Intensive Applications:

This method involves using Docker containers to run specific applications known for high CPU utilization, allowing you to simulate real-world workloads and monitor CPU performance under those conditions.

Explanation: By containerizing CPU-intensive applications, you can create reproducible test environments and isolate the benchmark from the host system’s configuration. This approach is particularly useful for testing how your CPU performs under specific workload scenarios. For instance, you might run a containerized build process or a scientific computing application.
Prerequisites: Ensure Docker is installed on your Debian system. If not, install it using:
```
sudo apt install docker.io
```
Usage Example:
Let’s use a Docker image that runs a CPU-intensive calculation. A simple example is using a container that calculates prime numbers. Create a Dockerfile:
```
FROM ubuntu:latest
RUN apt-get update && apt-get install -y bc
CMD seq 2 100000 | xargs -I {} echo "scale=0; if ({} % 2 == 0) {print 0} else {sqrt({})} " | bc -l | grep ".0000000000" | wc -l
```
This Dockerfile installs bc (a command-line calculator) and then calculates the square root of odd numbers between 2 and 100000 using bc. It then filters and counts the results.

Build the Docker image:
```
docker build -t prime-calculator .
```
Run the Docker container:
```
docker run prime-calculator
```
While the container is running, monitor the CPU usage using tools like top or htop on your Debian host system. This will give you a real-time view of the CPU load generated by the application within the container.

These alternative methods provide different perspectives on stress testing and benchmarking CPU performance, offering flexibility based on your specific testing needs and the types of workloads you want to simulate. The choice of method depends on the level of detail required and the types of applications being tested. Remember to always monitor system temperatures during stress tests to prevent hardware damage.