Linux offers a wide range of benchmarking tools, but no single tool is the right choice for every type of performance test. You may want to check how fast your CPU performs, measure memory bandwidth, test storage speed and latency, compare graphics performance, or see how much network throughput your system can handle.

Some benchmarking tools give you a simple score that makes comparisons easier, while others provide detailed results such as IOPS, bandwidth, latency, and execution time. There are also simple tools for quick checks and more advanced options for detailed testing.

In this article, we cover tools for benchmarking CPU, GPU, RAM, storage, network, complete Linux systems, and VPS servers, helping you choose the right tool for the component or workload you want to test.

Quick Answer: Which Linux Benchmarking Tool Should You Use?

The right Linux benchmarking tool depends on what you want to measure. For complete system testing, Phoronix Test Suite is a strong choice, while Sysbench works well for quick CPU, memory, file I/O, and database tests. Geekbench 7 makes CPU and GPU comparisons straightforward, and Hardinfo2 provides a graphical option for quick benchmarks.

✓ Phoronix Test Suite — complete, repeatable benchmark suites
✓ Sysbench — CPU, memory, file I/O, and database testing
✓ Geekbench 7 — CPU and GPU comparisons
✓ Hardinfo2 — graphical system information and benchmarks
✓ fio — SSD, NVMe, and storage testing
✓ ioping — storage latency and responsiveness
✓ STREAM — memory bandwidth
✓ glmark2 — OpenGL graphics
✓ vkmark — Vulkan graphics
✓ iperf3 — network throughput
✓ hyperfine — command and script timing
✓ YABS — quick VPS and server benchmarking

Linux Benchmarking Tools Overview

What Should You Benchmark on a Linux System?

Before choosing a benchmarking tool, first decide what you actually want to learn about your Linux system. A fast CPU does not necessarily mean fast storage or networking, so each part needs to be measured differently.

✓ CPU performance: Test single-core performance for workloads that rely mainly on one core and multi-core performance for workloads that can use several cores.

✓ Memory performance: Measure RAM bandwidth and memory operations to see how quickly data can move between the processor and memory.

✓ Storage throughput: Measure sequential and random read/write speeds to understand how quickly an SSD, NVMe drive, or other storage can transfer data.

✓ Storage IOPS: Measure how many read/write operations storage can complete per second, which matters for databases, virtual machines, and busy servers.

✓ Storage latency: Check how quickly individual I/O requests complete. Lower latency generally means more responsive storage.

✓ GPU performance: Measure graphics rendering or GPU compute performance.

✓ Network performance: Test TCP/UDP throughput and, where relevant, jitter and packet loss between endpoints.

✓ Application performance: Measure how long commands, scripts, builds, or programs take to complete.

✓ Whole-system performance: Use combined workloads when you want a broader view across multiple components.

Choose a benchmark based on the performance metric you need to measure, not simply because a particular tool is popular.

Phoronix Test Suite — Best for Comprehensive Linux Benchmarking

Phoronix Test Suite is an open-source benchmarking and automated testing framework. It is useful when you want to test more than one part of a Linux system or repeat the same benchmark across different machines.

Rather than being limited to one type of test, it works with test profiles and suites covering areas such as CPU, GPU, memory, storage, compilation, encoding, and application workloads. A test profile defines how an individual benchmark is installed, configured, and executed, while a test suite can group multiple tests together.

Phoronix Test Suite also integrates with OpenBenchmarking.org, which provides test profiles, test suites, public results, and tools for comparing benchmark results.

Basic Workflow

The normal process is straightforward:

Install Phoronix Test Suite → choose a test or suite → run it → review the results

For example, Sysbench is available as an OpenBenchmarking test profile and can be run through Phoronix Test Suite with:

phoronix-test-suite benchmark sysbench

The test profile handles the benchmark configuration and execution, helping make it easier to run the same test again on another Linux system.

Why Repeatable Tests Matter

If you change the workload or benchmark settings between systems, the results may no longer provide a fair comparison. Phoronix Test Suite is designed around reproducible testing and can automate tasks such as dependency handling, test installation, execution, and result collection.

This makes it particularly useful when comparing processors, graphics cards, storage devices, Linux configurations, software versions, or complete systems under consistent test conditions.

Best for: Broad system benchmarking, hardware comparisons, and repeatable testing across Linux systems.

Main limitation: Phoronix Test Suite is more involved than a small single-purpose tool, so it can be unnecessary when you only need one quick measurement.

Sysbench — Best for Quick CPU, Memory and Database Tests

Sysbench is a lightweight command-line benchmarking tool that is useful when you want to test a specific part of a Linux system without setting up a large benchmark suite. It is also easy to include in scripts when the same test needs to be repeated across different systems.

Sysbench can run several types of tests:

✓ CPU: Measures CPU performance using calculations based on prime numbers.
✓ Memory: Measures memory read or write performance and transfer speed.
✓ File I/O: Tests storage using sequential and random read/write workloads.
✓ Threads and mutexes: Can be used to examine thread scheduling and synchronization behavior.
✓ Database/OLTP: Supports script-based database workloads for systems such as MySQL and PostgreSQL.

Quick CPU Benchmark

For example, you can run a CPU test with:

sysbench cpu --cpu-max-prime=20000 run

Sysbench calculates prime numbers up to the specified limit and reports statistics including events per second, total execution time, and latency. When comparing systems, use the same Sysbench version and identical test settings so the results remain meaningful.

Best for: Administrators and developers who need quick, repeatable, and scriptable CPU, memory, I/O, or database tests.

Main limitation: Sysbench focuses on specific synthetic and database workloads rather than providing the broad catalogue of application and hardware benchmarks available through Phoronix Test Suite.

Geekbench 7 — Best for Easy CPU and GPU Comparisons

Geekbench 7 is a cross-platform benchmark designed to make CPU and GPU performance easy to measure and compare. Because Geekbench is available across multiple operating systems, it is useful when you want to compare a Linux machine with other systems running the same Geekbench version.

The CPU benchmark produces separate single-core and multi-core scores. The single-core score represents workloads that rely mainly on one processor core, while the multi-core score shows performance when work can be distributed across multiple cores.

Geekbench 7 also includes GPU Compute benchmarks for measuring computational workloads on supported graphics hardware and compute APIs. Rather than presenting large amounts of raw performance data, Geekbench converts its test results into standardized scores, making comparisons easier to understand.

Its testing process is straightforward: run the appropriate benchmark and compare the resulting scores with another system or configuration.

Comparing Geekbench Scores

Geekbench scores should only be directly compared when they come from the same major Geekbench version. Geekbench 7 uses updated workloads and scoring compared with earlier releases, so a Geekbench 7 score should not be treated as directly equivalent to a Geekbench 6 or Geekbench 5 score.

Best for: Users who want straightforward CPU and GPU scores for comparing Linux hardware or systems across supported platforms.

Main limitation: A standardized benchmark score provides a convenient comparison, but it cannot represent the performance of every application or real-world workload.

Hardinfo2 — Best Graphical Linux Benchmarking Tool

Hardinfo2 is a maintained continuation of the original Hardinfo project. It combines detailed Linux system information with built-in benchmarks, making it useful when you want to inspect your hardware and run basic performance tests from the same application.

Its graphical interface can display information about your processor, memory, storage devices, operating system, kernel, network interfaces, PCI devices, USB devices, and other hardware. This is useful when checking benchmark results because you can also see the system configuration behind those results.

Hardinfo2 includes benchmarks covering areas such as CPU performance, memory/cache performance, and storage, with the available tests depending on the version and system. Results provide a quick way to examine performance or compare systems without building a complex benchmark workload.

The graphical interface also makes Hardinfo2 approachable for desktop Linux users who would rather not work entirely with terminal commands.

When Hardinfo2 Makes Sense

Hardinfo2 is a good starting point when you want to identify your Linux hardware and run quick benchmarks in one place. It is better suited to general checks than detailed workload simulation.

Best for: Desktop Linux users who want an accessible graphical interface for system information and quick benchmarking.

Main limitation: Its built-in benchmarks provide a general performance view, but they do not replace specialized tools such as fio when you need detailed storage workloads, IOPS, bandwidth, and latency measurements.

fio — Best for SSD, NVMe and Storage Benchmarking

fio (Flexible I/O Tester) is a powerful Linux tool for measuring SSD, NVMe, disk, and server-storage performance. Its main advantage is that you can define the type of I/O workload you want to test instead of relying on a single generic disk-speed test.

With fio, you can test:

✓ Sequential I/O: Large blocks of data read or written in order, useful for workloads such as large-file transfers.

✓ Random I/O: Data accessed at different locations, which is more relevant to workloads such as databases and virtual machines.

✓ Read, write, or mixed workloads: Test reads and writes separately or combine them in a chosen ratio.

✓ Block size: Control the amount of data handled by each I/O operation, such as 4 KiB for small random operations or larger blocks for sequential transfers.

✓ I/O depth: Control how many I/O requests can be outstanding at a time, which is particularly important when testing NVMe devices and server storage.

Understanding fio Results

Three measurements are especially useful:

✓ IOPS — the number of I/O operations completed per second.

✓ Bandwidth — how much data is transferred per second, commonly shown in MiB/s or GiB/s.

✓ Latency — how long I/O operations take to complete.

A database may care strongly about small-block random IOPS and latency, while large-file workloads may care more about sequential bandwidth. This is why the fio workload should reflect what the storage will actually be used for.

Safe fio Example

The following example creates a temporary 1 GiB test file in the current directory and runs a 4 KiB random-read test:

fio --name=random-read \

    --filename=./fio-testfile \

    --size=1G \

    --rw=randread \

    --bs=4k \

    --ioengine=libaio \

    --iodepth=32 \

    --direct=1

After testing, the file can be removed with:

rm ./fio-testfile

Important: Be very careful when specifying --filename. Do not point a write benchmark at a production disk, partition, or device such as /dev/sda or /dev/nvme0n1 unless you fully understand the consequences. Raw-device write tests can overwrite existing data.

Best for: Detailed SSD, NVMe, server-storage, IOPS, bandwidth, and latency testing.

Main limitation: fio is highly configurable, but unrealistic block sizes, queue depths, read/write ratios, or caching settings can produce results that do not represent your actual workload.

ioping — Best for Quick Storage Latency Testing

ioping is a lightweight command-line tool for checking how quickly a Linux storage system responds to I/O requests. The idea is similar to the network ping command, but instead of checking the response time of another host, ioping measures the response time of a disk, filesystem, directory, or storage path.

This makes ioping useful when you want a quick answer to the question: How responsive is my storage?

For example, a drive may show good transfer speeds during a large sequential file test but still respond slowly to individual I/O requests. That delay can affect databases, virtual machines, applications, and other workloads that depend on frequent storage access.

Quick ioping Test

To test the storage containing your current directory, you can run:

ioping .

ioping repeatedly sends I/O requests and reports how long they take to complete. You can stop the test with Ctrl+C.

The response time is shown using units such as microseconds (µs) or milliseconds (ms). In the same test environment, lower latency generally means the storage is responding more quickly. Results can vary with caching, system load, storage technology, and the path being tested, so comparisons should use similar conditions.

ioping vs fio

The two tools answer different questions. ioping focuses on storage response time, making it convenient for quick latency checks. fio can create much more detailed workloads for measuring IOPS, bandwidth, latency, block sizes, queue depths, and read/write patterns.

Best for: Quick disk, filesystem, and storage-latency or responsiveness checks.

Main limitation: ioping provides a focused view of I/O latency and responsiveness; it does not replace fio when you need detailed storage workload benchmarking.

STREAM — Best for Memory Bandwidth Testing

STREAM is a focused benchmark for measuring sustainable memory bandwidth. Instead of trying to score the entire Linux system, it measures how quickly the processor and memory subsystem can move large amounts of data to and from main memory.

STREAM uses four simple operations:

✓ Copy: Copies data from one memory array to another.
✓ Scale: Reads data, multiplies it by a value, and stores the result.
✓ Add: Reads two arrays, adds their values, and writes the result to another array.
✓ Triad: Combines addition and multiplication while reading and writing multiple arrays.

These tests create different patterns of memory reads, writes, and arithmetic operations without turning the benchmark into a general CPU test.

Understanding STREAM Results

STREAM reports performance as a memory transfer rate, commonly in MB/s. A higher result means more data was transferred per second during that particular test.

The Triad result is commonly useful when discussing STREAM performance because it combines multiple memory operations, but all four results provide information about the system's sustained memory bandwidth.

STREAM can be useful when comparing RAM configurations, memory channels, processors, or complete systems under the same test conditions. For example, it can help show the effect of changing memory configuration when the workload is limited by memory bandwidth.

It is most relevant to workloads that move large amounts of data through memory, such as scientific computing and other memory-intensive processing.

Best for: Measuring sustained RAM and memory-subsystem bandwidth.

Main limitation: STREAM measures a specific aspect of memory performance. It does not measure memory latency or provide an overall score for CPU or complete-system performance.

glmark2 — Best for OpenGL Graphics Benchmarking

glmark2 is a graphics benchmark designed to test OpenGL and OpenGL ES performance. It is useful when you want a quick way to check how a Linux graphics stack performs without running a full game or application benchmark.

Instead of relying on a single rendering test, glmark2 runs a collection of graphics scenes that exercise different OpenGL features and rendering workloads. These can include areas such as texture handling, shading, lighting, geometry, and other graphics operations.

At the end of a normal run, glmark2 reports a combined glmark2 score. The score can be useful when comparing two GPUs, graphics drivers, or system configurations, provided the benchmark is run with the same settings and under similar conditions.

Running a Basic glmark2 Test

After installing glmark2, you can start the standard benchmark with:

glmark2

The benchmark runs its scenes and displays performance information before reporting the final score.

For a meaningful comparison, keep the display resolution, glmark2 settings, graphics driver, desktop environment, power mode, and other relevant conditions as consistent as possible. Changing the resolution or test configuration can significantly affect the result.

glmark2 is also useful when checking whether a graphics-driver change improves or reduces OpenGL performance on the same Linux machine.

Best for: Testing and comparing OpenGL/OpenGL ES graphics performance on Linux.

Main limitation: The glmark2 score represents its own OpenGL workloads. It should not be treated as equivalent to gaming performance, because individual games can use different graphics APIs, engines, effects, and CPU/GPU workloads.

vkmark — Best for Vulkan Graphics Benchmarking

vkmark is a Linux graphics benchmark designed specifically for the Vulkan graphics API. It complements glmark2 rather than replacing it: glmark2 focuses on OpenGL/OpenGL ES, while vkmark provides a way to test Vulkan graphics performance.

vkmark runs a collection of configurable Vulkan scenes that exercise different parts of the graphics pipeline. During a benchmark, these scenes render workloads and report performance information that can be used to compare Vulkan-capable GPUs, drivers, or system configurations.

Why Test Vulkan Separately from OpenGL?

OpenGL and Vulkan are different graphics APIs, so good performance in an OpenGL benchmark does not automatically tell you how the same system will perform with Vulkan.

Vulkan gives applications more direct control over GPU resources and is used by modern games, graphics applications, and compatibility technologies. If the software you care about uses Vulkan, a Vulkan-focused benchmark provides a more relevant graphics test than relying only on an OpenGL score.

vkmark can also help when checking the effect of a GPU upgrade or graphics-driver change. For a meaningful comparison, use the same vkmark scenes, resolution, driver settings, power mode, and other relevant test conditions.

vkmark vs glmark2

The distinction is straightforward:

glmark2 = OpenGL/OpenGL ES benchmarking
vkmark = Vulkan benchmarking

They measure workloads through different graphics APIs, so their results should not be compared directly as if their scores represented the same test.

Best for: Testing and comparing Vulkan graphics performance on Linux.

Main limitation: vkmark measures its own Vulkan graphics workloads. Its results do not represent the performance of every Vulkan game, graphics application, or GPU-compute workload.

iperf3 — Best for Network Throughput Testing

iperf3 is a command-line tool for measuring network performance between two reachable endpoints. It uses a client/server model: one system runs as the iperf3 server, while another connects as the client and sends test traffic across the network.

For TCP tests, iperf3 primarily measures how much data the connection can transfer over a given period. This makes it useful for checking LAN links, server-to-server connections, VPN paths, cloud networks, and other network routes.

iperf3 also supports UDP testing, where results can include throughput along with jitter and packet loss. These measurements are useful when evaluating network behavior for workloads that are sensitive to inconsistent delivery.

Running a Basic iperf3 Test

On the first Linux system, start the server:

iperf3 -s

On the second system, connect to the server using its IP address:

iperf3 -c 192.0.2.10

Replace 192.0.2.10 with the actual IP address of the iperf3 server.

A standard TCP test measures traffic from the client to the server. To test the reverse direction, use:

iperf3 -c 192.0.2.10 -R

You can also use multiple parallel TCP streams with -P. For example:

iperf3 -c 192.0.2.10 -P 4

This can be useful when a single TCP connection does not fully use a high-bandwidth or higher-latency network path.

Understanding the Results

Throughput is commonly reported in Mbits/sec (Mbps) or Gbits/sec (Gbps). A higher value means more data was transferred per second between the two test endpoints. For UDP tests, also pay attention to jitter and packet loss, since throughput alone does not describe connection quality.

Best for: Measuring network throughput and related characteristics between Linux systems or other reachable iperf3 endpoints.

Main limitation: iperf3 measures the performance of the network path between the selected endpoints. It should not automatically be treated as a general measurement of your internet connection or ISP speed.

hyperfine — Best for Benchmarking Commands and Scripts

hyperfine is a command-line benchmarking tool designed to measure how long commands and programs take to run. It is useful when you want to compare scripts, command-line applications, build commands, data-processing tasks, or two different ways of performing the same job.

Instead of timing a command only once, hyperfine automatically runs it multiple times. It then summarizes the results using statistics such as the mean execution time, standard deviation, minimum, and maximum time. This gives you a more useful comparison than relying on a single run that may have been affected by temporary system activity.

Warm-Up Runs

The first execution of a program can behave differently because of filesystem caching, application initialization, or other startup effects. hyperfine can perform warm-up runs before it starts collecting benchmark measurements.

For example:

hyperfine --warmup 3 'your-command'

This runs the command three times as a warm-up before the measured runs begin.

Comparing Two Commands

One of hyperfine's most useful features is comparing commands directly. For example:

hyperfine 'grep -R "example" ./data' 'rg "example" ./data'

hyperfine runs both commands repeatedly and reports their timing statistics, making it easier to see which completes faster under the same test conditions.

This approach can be useful when comparing two implementations of a script, different compiler or build options, CLI utilities, or changes made during application development.

Understanding the Results

For execution-time benchmarks, a lower mean time generally indicates faster completion. However, also look at the variation between runs. Large differences can indicate that background activity, caching, or another system condition is influencing the test.

Best for: Developers and administrators who want to measure and compare the execution time of commands, scripts, builds, and CLI applications.

Main limitation: hyperfine measures the execution time of commands and programs. It is not designed to provide a broad benchmark of CPU, memory, storage, GPU, or complete-system performance.

YABS — Best for Quick VPS and Server Benchmarking

YABS (Yet-Another-Bench-Script) is a Linux benchmarking script designed to give you a quick performance overview of a VPS or server. Instead of configuring several benchmark tools separately, it brings common server tests together in one automated run.

YABS uses established tools for different parts of the benchmark:

✓ fio — tests disk performance using mixed random read/write workloads and reports results such as throughput and IOPS.
✓ iperf3 — measures network upload and download performance against multiple test locations.
✓ Geekbench — measures CPU and overall system performance using standardized scores.

By default, YABS currently runs Geekbench 6. If you want to use the newer Geekbench 7, YABS supports it through the -7 option.

Running a Standard YABS Test

A normal benchmark can be started with:

curl -sL yabs.sh | bash

This runs the standard disk, network, and Geekbench tests and displays the results in the terminal.

To run YABS with Geekbench 7 instead of the default Geekbench 6, use:

curl -sL yabs.sh | bash -s -- -7

Using YABS for VPS Comparisons

YABS is useful after deploying a VPS or server when you want a quick view of its disk, network, and CPU performance. It can also help when comparing VPS plans because the same set of tests can be run on each server.

Keep in mind that results from a VPS can change between runs. On shared infrastructure, available CPU, storage, and network resources may be affected by activity elsewhere on the host. Running the benchmark more than once gives you a better picture than relying on a single result.

YABS network tests can also consume a significant amount of bandwidth, so this should be considered on servers with limited data allowances.

Best for: Quickly checking and comparing Linux VPS and server performance.

Main limitation: YABS prioritizes convenience over detailed workload control. For more specific testing, running fio, iperf3, Geekbench, or another specialized benchmark separately gives you greater control over the test configuration.

Benchmarking vs Stress Testing: Where Does stress-ng Fit?

Benchmarking and stress testing both put your Linux system under load, but they serve different purposes. A benchmark measures performance under a defined workload and gives you results that can be used to evaluate or compare systems. A stress test deliberately places components under sustained or heavy load to see how the system behaves.

stress-ng belongs mainly in the second category. It can exercise the CPU, memory, storage I/O, scheduler, virtual memory, and other Linux subsystems through a large collection of stressors.

This makes stress-ng useful when you want to check system stability, cooling and thermal behavior, or performance under sustained load. For example, you might use a benchmark to measure CPU performance and then use stress-ng to see whether the system remains stable when the processor is heavily loaded for an extended period.

stress-ng can report performance-related metrics for some stressors, but these should not be treated as precision benchmark results.

Best use: Run benchmarking tools when you want to measure performance; use stress-ng alongside them when you also want to test stability and sustained-load behavior.

How to Get Reliable Linux Benchmark Results

Running a benchmark is easy, but getting results that you can meaningfully compare requires consistent test conditions. Small differences in system load, temperature, power settings, or benchmark configuration can affect the numbers.

✓ Keep the system as idle as possible: Close unnecessary applications, background jobs, downloads, and other workloads before testing.

✓ Use the same benchmark version: Results from different major versions may use different workloads or scoring methods and may not be directly comparable.

✓ Keep test settings identical: Use the same resolution, block size, I/O depth, test duration, thread count, and other relevant settings when comparing systems.

✓ Use consistent power settings: A laptop in power-saving mode can perform differently from the same machine in performance mode.

✓ Record the system configuration: Note the CPU, RAM, GPU, storage, Linux distribution, kernel, drivers, and benchmark version so you know what produced the result.

✓ Run tests more than once: Repeated runs help reveal unusual results caused by temporary system activity.

✓ Watch temperatures and throttling: CPU and GPU performance can fall when components become too hot and reduce their clock speeds.

✓ Consider storage caching: Cached data can make storage results look faster than the underlying device. For fio, use block sizes, I/O depths, and read/write patterns that reflect the workload you actually care about.

✓ Give VPS results context: Performance on shared infrastructure can change with host load, so compare VPS instances under similar conditions and use multiple runs.

Finally, do not judge a system from one headline score. Look at the measurements that matter to your workload, such as latency, IOPS, bandwidth, execution time, or sustained performance.

How to Read Linux Benchmark Results

Benchmark results can use different scores and units depending on what is being tested. Understanding a few common measurements makes it much easier to tell what the numbers actually mean.

✓ Benchmark score: A higher score generally indicates better performance, but only compare scores produced by the same benchmark and major version.

✓ MB/s or GB/s: Shows how much data can be transferred per second. You will commonly see these measurements in storage and memory-bandwidth tests. Higher throughput generally means faster data transfer.

✓ IOPS: Means input/output operations per second. It shows how many storage operations can be completed each second. Higher IOPS can be important for databases, virtual machines, and workloads involving lots of small I/O requests.

✓ Latency: Shows how long an operation takes to complete. It may be reported in milliseconds or microseconds. Lower latency is generally better.

✓ FPS: Frames per second is used in graphics benchmarks. Higher FPS means more frames were rendered each second under that specific test.

✓ Execution time: Shows how long a command, script, or workload takes to finish. Lower execution time generally means better performance.

✓ Single-core and multi-core scores: Single-core results show performance using workloads centered on one CPU core, while multi-core results reflect workloads that can use multiple cores.

✓ Network throughput: Usually reported in Mbps or Gbps and shows how much data was transferred between the test endpoints per second.

Most importantly, compare like with like. Results from different benchmark tools, versions, workloads, or settings should not be treated as directly comparable simply because they use similar-looking numbers.