Google Benchmark 微基准测试 on Dorkytiger 的小屋

基本用法

Mon, 01 Jan 0001 00:00:00 +0000

一、安装

git clone https://github.com/google/benchmark.git
cd benchmark
cmake -DCMAKE_BUILD_TYPE=Release -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
make -j4
sudo make install

二、编写第一个基准测试

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

// 测试 vector 求和的不同方式
static void BM_Sum_Loop(benchmark::State& state) {
    std::vector<int> v(state.range(0));
    std::iota(v.begin(), v.end(), 0);

    for (auto _ : state) {
        long long sum = 0;
        for (int x : v) sum += x;
        benchmark::DoNotOptimize(sum);
    }
}
BENCHMARK(BM_Sum_Loop)->Arg(1000)->Arg(10000)->Arg(100000);

static void BM_Sum_STL(benchmark::State& state) {
    std::vector<int> v(state.range(0));
    std::iota(v.begin(), v.end(), 0);

    for (auto _ : state) {
        auto sum = std::accumulate(v.begin(), v.end(), 0LL);
        benchmark::DoNotOptimize(sum);
    }
}
BENCHMARK(BM_Sum_STL)->Arg(1000)->Arg(10000)->Arg(100000);

BENCHMARK_MAIN();

# 编译并运行
g++ -O2 -o bench bench.cpp -lbenchmark
./bench

# 输出示例：
# --------------------------------------------------------------
# Benchmark              Time     CPU  Iterations
# --------------------------------------------------------------
# BM_Sum_Loop/1000     432 ns  431 ns    1623905
# BM_Sum_Loop/10000   4123 ns 4120 ns     169853
# BM_Sum_Loop/100000 41234 ns 41230 ns     16985
# BM_STL_Sum/1000      428 ns  427 ns    1638281
# BM_STL_Sum/10000    4128 ns 4125 ns     169720
# BM_STL_Sum/100000  41280 ns 41270 ns     16972

# 分析：for 循环和 std::accumulate 几乎没区别（编译器优化到一样了）

三、`for (auto _ : state)` 的作用

// 这个循环框架帮做了 3 件事：
static void BM_Example(benchmark::State& state) {
    // ① 初始化（只在测试开始前执行一次）
    std::vector<int> data(1000000);

    // ② 被测代码在循环中重复执行
    for (auto _ : state) {
        // benchmark 框架会：
        //   - 自动计算执行了多少次以达到统计显著性
        //   - 排除循环本身的时间开销
        //   - 多次运行取平均值
        do_something(data);
    }

    // ③ 这里的代码只有在所有循环结束后执行一次
    // 可以在测试结束时做结果校验
}

`DoNotOptimize` 和 `ClobberMemory`

Mon, 01 Jan 0001 00:00:00 +0000

一、为什么需要它们

编译器非常聪明，会优化掉"看起来没用的代码"：

void test_sine() {
    double x = 0.0;
    for (int i = 0; i < 100000; i++) {
        x = sin(x);  // 编译器发现 x 没有后续使用 → 整个循环被删掉！
    }
}

// 如果你用 benchmark 测试这个函数，测出来时间 ≈ 0ns
// 因为编译器把整个循环优化掉了

二、正确用法

static void BM_Sine(benchmark::State& state) {
    double x = 0.0;

    for (auto _ : state) {
        x = sin(x);
        // 告诉编译器：这个值后续会被使用，不能删
        benchmark::DoNotOptimize(x);
    }

    // 最终把 x 输出，也是告诉编译器"x 确实被用了"
    std::cout << x << std::endl;
}

static void BM_Memcpy(benchmark::State& state) {
    char src[1024] = {}, dst[1024] = {};

    for (auto _ : state) {
        memcpy(dst, src, 1024);
        // 告诉编译器：dst 的内容被"外部"使用了
        benchmark::ClobberMemory();
    }
}

// 对比没有 ClobberMemory 的版本——编译器可能会把 memcpy 优化掉
static void BM_Memcpy_Wrong(benchmark::State& state) {
    char src[1024] = {}, dst[1024] = {};

    for (auto _ : state) {
        memcpy(dst, src, 1024);
        // dst 后续没被使用 → 编译器可能优化掉 memcpy
        // 测出来的时间 ≈ 0ns
    }
}

参数化基准测试

Mon, 01 Jan 0001 00:00:00 +0000

一、自动生成测试用例

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

// 测试不同 N 下 vector 的插入性能
static void BM_Vector_PushBack(benchmark::State& state) {
    for (auto _ : state) {
        std::vector<int> v;
        // state.range(0) 是传入的参数
        for (int i = 0; i < state.range(0); i++) {
            v.push_back(i);
        }
        benchmark::DoNotOptimize(v);
    }
}
// 生成一系列参数：8, 16, 32, 64, 128, 256, 512, 1024
BENCHMARK(BM_Vector_PushBack)->RangeMultiplier(2)->Range(8, 8 << 7);

// 测试不同的 reserve 策略
static void BM_Vector_Reserve(benchmark::State& state) {
    for (auto _ : state) {
        std::vector<int> v;
        v.reserve(state.range(0));
        for (int i = 0; i < state.range(0); i++) {
            v.push_back(i);
        }
        benchmark::DoNotOptimize(v);
    }
}
BENCHMARK(BM_Vector_Reserve)->RangeMultiplier(2)->Range(8, 8 << 7);

// 对比两个版本的输出，可以看到 reserve 后的版本快多少

二、对比测试结果

./bench

# 输出示例：
# -------------------------------------------------------------------------
# Benchmark                               Time   CPU     Iterations
# -------------------------------------------------------------------------
# BM_Vector_PushBack/8                   23 ns  22 ns     31875984
# BM_Vector_PushBack/64                 155 ns 155 ns      4514715
# BM_Vector_PushBack/512                1252 ns 1250 ns     560000
# BM_Vector_PushBack/4096              10123 ns 10120 ns     69173
# BM_Vector_PushBack/32768            101234 ns 101200 ns     6917
#
# BM_Vector_Reserve/8                    12 ns  12 ns     58337169  ← 快了近一倍
# BM_Vector_Reserve/64                   83 ns  83 ns      8435509
# BM_Vector_Reserve/512                 551 ns  551 ns     1269806
# BM_Vector_Reserve/4096               4123 ns  4120 ns     169720
# BM_Vector_Reserve/32768             37893 ns  37890 ns     18475

# 结论：reserve 后 push_back 快约 2x（省掉了多次扩容 + 搬移）

三、用 `compare.py` 生成对比报告

# 先编译优化前的版本
g++ -O2 -o bench_before bench.cpp -lbenchmark
./bench_before --benchmark_out=before.json --benchmark_out_format=json

# 修改代码做优化

# 再编译优化后的版本
g++ -O2 -o bench_after bench.cpp -lbenchmark
./bench_after --benchmark_out=after.json --benchmark_out_format=json

# 用 benchmark 自带的比较脚本生成报告
python3 /path/to/benchmark/tools/compare.py benchmarks before.json after.json

# 输出：
# Run on (8 X 2400 MHz CPU s)
# CPU Caches:
#   L1 Data 32K (x4)
#   L1 Instruction 32K (x4)
#   L2 Unified 256K (x4)
#   L3 Unified 8192K (x1)
# Loading benchmarks...
# Comparing before.json to after.json
# Benchmark                          Time        CPU     Time Old   Time New  CPU Old   CPU New
# --------------------------------------------------------------------------------------------
# BM_Vector_PushBack/8              -0.4868    -0.4868        23        12       22        12
# BM_Vector_PushBack/64             -0.4623    -0.4623       155        83      155        83
# BM_Vector_PushBack/512            -0.5595    -0.5595      1252       551     1250       552
# 负值表示时间减少了（变快了），所以这个优化是有效的

你的 SimpleAsyncLogger 可以做这样的 benchmark

Mon, 01 Jan 0001 00:00:00 +0000

#include <benchmark/benchmark.h>
#include "logger.h"  // 你的日志库

static void BM_Logger_Write(benchmark::State& state) {
    logger_init("./bench.log", LOG_LEVEL_INFO);
    const char* msg = "benchmark test message %d";

    for (auto _ : state) {
        logger_write(LOG_LEVEL_INFO, msg, state.iterations());
        benchmark::DoNotOptimize(msg);
    }

    logger_destroy();
}
BENCHMARK(BM_Logger_Write)->Iterations(100000);

// 对比 spdlog
#include <spdlog/spdlog.h>
static void BM_Spdlog_Write(benchmark::State& state) {
    auto logger = spdlog::basic_logger_mt("bench", "./spdlog_bench.log");

    for (auto _ : state) {
        logger->info("benchmark test message {}", state.iterations());
    }
}
BENCHMARK(BM_Spdlog_Write)->Iterations(100000);

BENCHMARK_MAIN();

// 编译：
// g++ -O2 -I./include -L./lib -lsalogger -lspdlog -lbenchmark -o bench bench.cpp

// 预期结果：
// --------------------------------------------------------------------
// Benchmark                        Time    CPU      Iterations
// --------------------------------------------------------------------
// BM_Logger_Write                 52 ns  51 ns      100000   ← 你的日志库
// BM_Spdlog_Write                520 ns 518 ns      100000   ← spdlog
//
// 52ns vs 520ns，你的日志库快 10 倍。
// 这就是"我做了性能对比，我的方案比主流的快 10 倍"——面试时可以拿出来的数字。

第四阶段总结

Mon, 01 Jan 0001 00:00:00 +0000

Google Benchmark 的核心用法：
    for (auto _ : state) 包裹被测代码
    DoNotOptimize 防止编译器优化掉测试
    ClobberMemory 防止内存操作被优化

参数化测试：
    Arg(N) → 指定单个参数
    Range(A, B) → 自动生成几何序列的参数

对比报告：
    compare.py before.json after.json
    精准看到优化前后的百分比变化

面试价值：
    "我的日志库 benchmark 显示比 spdlog 快 10 倍，生产路径延迟 52ns"
    有数字支撑的技术决策，比说"我的日志库很快"有说服力得多

Google Benchmark 微基准测试 on Dorkytiger 的小屋

基本用法

一、安装

二、编写第一个基准测试

三、for (auto _ : state) 的作用

`DoNotOptimize` 和 `ClobberMemory`

一、为什么需要它们

二、正确用法

参数化基准测试

一、自动生成测试用例

二、对比测试结果

三、用 compare.py 生成对比报告

你的 SimpleAsyncLogger 可以做这样的 benchmark

第四阶段总结

三、`for (auto _ : state)` 的作用

三、用 `compare.py` 生成对比报告