Installing Google Benchmark requires cloning the benchmark and googletest repository first, creating a build directory, and using CMake to compile and install; 2. Write main.cpp containing multiple performance test functions, register the test function using BENCHMARK macro, prevent optimization through benchmark::DoNotOptimize, set the input scale with Arg and Range, and analyze the time complexity by Complexity; 3. Write the CMakeLists.txt file, configure the minimum version of CMake, project name, and C 17 standard, use find_package to find benchmark, and build executable through add_executable and target_link_libraries; 4. Run cmake .. and make in the build directory Compile the project, execute ./bench to run benchmark tests, and add parameters such as --benchmark_filter or --benchmark_format=json to control the output; 5. The output results show the average time and execution times of each test case, which can be used to compare the performance differences between different implementations, and finally draw the conclusion that Google Benchmark can effectively perform micro benchmark tests.

Writing a C Google Benchmark example is actually very simple. Here is a complete, directly run example showing how to use the Google Benchmark library to measure the performance of a function.

? 1. Install Google Benchmark

If you haven't installed Google Benchmark, you can install it in the following ways (taking Ubuntu as an example):

 git clone https://github.com/google/benchmark.git
git clone https://github.com/google/googletest.git benchmark/googletest

mkdir build && cd build
cmake ../benchmark
make -j8
sudo make install

Make sure you have CMake and compilers (such as g) that support C11 or higher.

? 2. Write benchmark sample code

Here is a simple main.cpp that compares two functions: std::sqrt and a loop version written manually (just to demonstrate performance differences).

 #include <benchmark/benchmark.h>
#include <cmath>
#include <vector>

// Tested function 1: Use std::sqrt
static void BM_SqrtStd(benchmark::State& state) {
    double x = 3.14159;
    for (auto _ : state) {
        benchmark::DoNotOptimize(std::sqrt(x));
        x = 0.00001; // Prevent it from being completely optimized}
}
BENCHMARK(BM_SqrtStd);

// Function under test 2: Simulate a "slow" operation (actually, it is still using sqrt, but add points to loop)
static void BM_SqrtLoop(benchmark::State& state) {
    double x = 3.14159;
    for (auto _ : state) {
        for (int i = 0; i < 10; i) {
            x = std::sqrt(xi);
        }
        benchmark::DoNotOptimize(x);
    }
}
BENCHMARK(BM_SqrtLoop);

// Compare vector push_back vs reserve push_back
static void BM_VectorPushBack(benchmark::State& state) {
    for (auto _ : state) {
        std::vector<int> v;
        for (int i = 0; i < state.range(0); i) {
            v.push_back(i);
        }
    }
    state.SetComplexityN(state.range(0));
}
BENCHMARK(BM_VectorPushBack)->Arg(1024)->Arg(8192);

static void BM_VectorPushBackWithReserve(benchmark::State& state) {
    for (auto _ : state) {
        std::vector<int> v;
        v.reserve(state.range(0)); // Assign for (int i = 0; i < state.range(0); i) {
            v.push_back(i);
        }
    }
    state.SetComplexityN(state.range(0));
}
BENCHMARK(BM_VectorPushBackWithReserve)->Arg(1024)->Arg(8192);

// Register a benchmark with parameters (using Range)
BENCHMARK(BM_VectorPushBack)->Range(8, 8 << 4); // 8 to 128
BENCHMARK(BM_VectorPushBackWithReserve)->Range(8, 8 << 4);

// Add an example of using BigO to measure complexity static void BM_Sort(benchmark::State& state) {
    std::vector<int> v(state.range(0));
    std::generate(v.begin(), v.end(), rand);

    for (auto _ : state) {
        std::sort(v.begin(), v.end());
    }
    state.SetComplexityN(state.range(0));
}
BENCHMARK(BM_Sort)->Range(1<<4, 1<<10)->Complexity(benchmark::oNLogN);

// Main function BENCHMARK_MAIN();

? 3. Write CMakeLists.txt

Create a CMakeLists.txt to compile the project:

 cmake_minimum_required(VERSION 3.14)
project(my_benchmark)

set(CMAKE_CXX_STANDARD 17)

find_package(benchmark REQUIRED)

add_executable(bench main.cpp)
target_link_libraries(bench benchmark::benchmark)

? 4. Compile and run

 mkdir build && cd build
cmake ..
Make

# Run benchmark
./bench

You can also add parameters to control the output format:

 ./bench --benchmark_format=json --benchmark_out=result.json

Or just run a test:

 ./bench --benchmark_filter=BM_Vector

? Output example (excerpt)

 BM_SqrtStd 10 ns 10 ns 100000000
BM_SqrtLoop 150 ns 150 ns 10000000
BM_VectorPushBack/1024 2.5 us 2.5 us 300000
BM_VectorPushBack/8192 30.2 us 30.2 us 23000
BM_VectorPushBackWithReserve/1024 1.8 us 1.8 us 400000
BM_VectorPushBackWithReserve/8192 20.1 us 20.1 us 35000

? Tips

• benchmark::DoNotOptimize(...) : prevents the compiler from optimizing the side effects without side effects.
• state.PauseTiming() / state.ResumeTiming() : Avoid counting measurement time during the setup phase.
• ->Arg() and ->Range() : used to test different input sizes.
• Complexity(benchmark::oNLogN) : Let benchmark automatically fit time complexity.

Basically that's it. Google Benchmark is quick to use and is suitable for microbenchmark testing, especially when optimizing critical path functions. Just remember not to test the code optimized by the compiler.

The above is the detailed content of C google benchmark example. For more information, please follow other related articles on the PHP Chinese website!