main_benchmark.cpp

#include <benchmark/benchmark.h>
#include "memory.hpp"
#include <cstdlib>
#include <mutex>
#include <vector>

// 保持与你 memory.hpp 中一致的块大小
constexpr std::size_t BLOCK_SIZE = 64; 
constexpr std::size_t BATCH_SIZE = 32; // 模拟真实的批量业务流

// 全局内存池指针和初始化标记
static FixedSizeMemory* g_pool = nullptr;
static std::once_flag g_pool_init_flag;

// 保证全局池只被安全地初始化一次
void InitGlobalPool() {
    // 假设你的构造函数只接收 block_size，或者有默认的 blocks_per_page
    g_pool = new FixedSizeMemory(BLOCK_SIZE);
}

// ==================== 1. 自定义内存池批量跑分 ====================
static void BM_CustomMemoryPool(benchmark::State& state) {
    // 安全地进行单次初始化
    std::call_once(g_pool_init_flag, InitGlobalPool);

    // 局部数组，用来存放批量申请的指针
    void* ptrs[BATCH_SIZE];

    // 跑分主循环
    for (auto _ : state) {
        // 步骤一：批量分配，让第一级 TLS 无锁路径吃满缓存
        for (std::size_t i = 0; i < BATCH_SIZE; ++i) {
            ptrs[i] = g_pool->allocate();
        }
        
        // 防止编译器把分配动作优化掉
        benchmark::DoNotOptimize(ptrs);
        
        // 步骤二：批量释放，触发本地缓存高水位积攒，绕开高频锁冲突
        for (std::size_t i = 0; i < BATCH_SIZE; ++i) {
            g_pool->deallocate(ptrs[i]);
        }
        
        // 刷新内存状态
        benchmark::ClobberMemory();
    }

    // 线程退出前，看门人兜底之外，强制刷新归还当前线程本地缓存
    g_pool->flush_thread_cache();
}
// 注册测试，覆盖 1, 4, 8, 16 核心线程压测
BENCHMARK(BM_CustomMemoryPool)->ThreadRange(1, 16)->UseRealTime();


// ==================== 2. 对照组：原生 malloc / free 跑分 ====================
static void BM_SystemMalloc(benchmark::State& state) {
    void* ptrs[BATCH_SIZE];

    for (auto _ : state) {
        for (std::size_t i = 0; i < BATCH_SIZE; ++i) {
            ptrs[i] = std::malloc(BLOCK_SIZE);
        }
        
        benchmark::DoNotOptimize(ptrs);
        
        for (std::size_t i = 0; i < BATCH_SIZE; ++i) {
            std::free(ptrs[i]);
        }
        
        benchmark::ClobberMemory();
    }
}
BENCHMARK(BM_SystemMalloc)->ThreadRange(1, 16)->UseRealTime();

// 自动生成含有 Google Benchmark 逻辑的 main 函数入口
BENCHMARK_MAIN();