How to Benchmark Linux Kernel Performance: From 6.6 LTS to 7.1

Introduction

Over the past three years, the Linux kernel has seen remarkable performance gains. For example, benchmarks comparing Linux 6.6 LTS to the upcoming Linux 7.1 on an AMD Threadripper system show a 13% improvement in geometric mean performance across various workloads. This guide will walk you through the process of benchmarking different Linux kernel versions on the same hardware, allowing you to measure performance evolution and verify such improvements yourself.

Whether you are a system administrator, developer, or enthusiast, understanding how to conduct fair and reproducible kernel benchmarks is essential. Follow these steps to set up your test environment, run consistent benchmarks, and analyze the results.

What You Need

• Hardware: A dedicated test machine (e.g., AMD Threadripper or any modern CPU) with enough RAM and storage. Avoid making hardware changes during the tests.
• Linux kernel source tarballs or Git repository for versions 6.6 LTS, 7.0, and 7.1 (or your chosen comparison points).
• Benchmark suite: Recommended Phoronix Test Suite (PTS) for standardized, reproducible tests. Alternatively, your own scripts.
• Bootloader (e.g., GRUB) configured to allow selecting between kernels.
• Basic command-line skills and root access.
• A clean base system (same OS distribution, same compiler versions, same drivers).

Step-by-Step Guide

Step 1: Prepare Your Testing Environment

Start with a stable Linux distribution (e.g., Ubuntu 24.04 LTS) installed on your test machine. Ensure all hardware components (CPU, RAM, storage, graphics) are identical throughout the tests. Disable automatic updates and power-saving features that might skew results. Record the exact hardware specifications and BIOS settings.

Step 2: Install Benchmark Tools

Install the Phoronix Test Suite using your package manager:

sudo apt install phoronix-test-suite  # Debian/Ubuntu

Or download the latest version from phoronix-test-suite.com. Choose a set of representative workloads (CPU, memory, disk, compilation) – for example, the pts/cpu test suite includes many benchmarks.

Step 3: Build and Install the First Kernel (Linux 6.6 LTS)

Obtain the Linux 6.6 LTS source from kernel.org. Configure it minimally – use the same configuration for all kernels (start from the distribution's config, then tweak only what is necessary). Compile and install:

make -j$(nproc)
sudo make modules_install install
sudo update-grub

Reboot into the new kernel. Verify with uname -r.

Step 4: Run Baseline Benchmarks on Linux 6.6 LTS

With the 6.6 kernel booted, run your benchmark suite. For example, to run the entire pts/cpu suite:

phoronix-test-suite benchmark pts/cpu

Let the tests complete. Save the results (PTS creates a result file). Run the suite at least three times and take the average to account for variance. Record all scores.

Step 5: Upgrade to Linux 7.0 and Repeat Benchmarks

Now install Linux 7.0 from source (or a pre-compiled package if available). Use the exact same .config file you used for 6.6. Follow the same build and install steps as in Step 3. Reboot, verify the kernel version, and run the identical benchmark suite with the same settings. Again, run multiple iterations and save results.

Step 6: Upgrade to Linux 7.1 and Final Benchmarks

Repeat the process for Linux 7.1 (the development branch at time of writing). This kernel may be available as a Git snapshot. Use the same configuration from the previous steps. Build, install, reboot, and run the benchmarks. Collect all results.

Step 7: Analyze and Compare Results

Export the results from PTS or create your own table. Compare raw scores for each benchmark across the three kernels. Use a spreadsheet to calculate the percentage change for each workload from 6.6 to 7.1. For example:

Benchmark	6.6 Score	7.1 Score	% Improvement
Build Linux kernel	100s	88s	12%

Step 8: Calculate Geometric Mean Improvement

To express overall performance gain, compute the geometric mean of all individual percentage improvements (using ratios). The formula: geometric mean = (∏(ratio_i))^(1/n). This avoids skew from outliers and matches common benchmarking practice. A geometric mean of 1.13 means a 13% improvement, as seen in the original comparison.

Tips for Reliable Benchmarks

• Isolate the system: Disable network, background services, and cron jobs.
• Use a dedicated test partition to avoid filesystem fragmentation differences.
• Maintain constant CPU frequency: Disable frequency scaling (e.g., cpupower frequency-set -g performance) and turbo boost if necessary.
• Document every change: Keep a log of kernel config options, module load order, and any patches applied.
• Run multiple passes: At least three runs per kernel; more if variance is high.
• Beware of chipset drivers: Newer kernels may enable additional hardware features. If the goal is a pure kernel comparison, ensure the same drivers and firmware versions are used.
• Consider using LTS kernels only for long-term trends – the original benchmark started with Linux 6.6 LTS as a stable baseline.

By following this guide, you can reproduce the 13% performance gain seen from Linux 6.6 LTS to 7.1 on AMD Threadripper, or measure the improvements on your own hardware. Remember that results may vary based on workload and system configuration.