// bench.cpp —— 几个最小的微基准。g++ -O2 -std=c++17 bench.cpp -o bench && ./bench
#include <algorithm>
#include <atomic>
#include <chrono>
#include <cstdio>
#include <map>
#include <memory>
#include <random>
#include <string>
#include <unordered_map>
#include <vector>

// 把 f 跑 n 次，返回平均每次的纳秒数
template <class F> double nsPerOp(long n, F f) {
    auto t0 = std::chrono::steady_clock::now();
    for (long i = 0; i < n; i++) f(i);
    std::chrono::duration<double, std::nano> d = std::chrono::steady_clock::now() - t0;
    return d.count() / n;
}

volatile long sink;  // 防止编译器把结果整个优化掉

// 3 号测试用：一条"关闭的"debug 日志，改前与改后（只保留关键路径上的工作）
enum Level { kDebug, kInfo, kWarn, kError, kOff };
struct OldLogger {
    bool enabled = true;
    Level global = kInfo;
    std::map<std::string, Level> moduleLevels{{"kv.put", kDebug}, {"net", kWarn}, {"raft", kInfo}};
    std::vector<int> sinks{1};
    bool shouldLog(Level lv, const std::string& module) const {
        if (!enabled || sinks.empty()) return false;
        Level th = global;
        auto it = moduleLevels.find(module);
        if (it != moduleLevels.end()) th = it->second;
        return lv >= th;
    }
    void log(Level lv, const std::string& module, const std::string& msg) {
        auto ts = std::chrono::system_clock::now().time_since_epoch().count();
        std::string line = std::to_string(ts) + " " + module + " " + msg;  // 先格式化
        if (!shouldLog(lv, module)) return;                                  // 再判断
        sink = (long)line.size();
    }
};
struct LogChannel {
    std::atomic<Level> threshold{kInfo};
    bool enabled(Level lv) const { return lv >= threshold.load(std::memory_order_relaxed); }
};

// 1 号测试：n 个随机键，有序 map 与哈希表各查 1,000,000 次
void lookupBench(long n) {
    std::mt19937_64 rng(42);
    std::vector<long> keys(n);
    for (auto& k : keys) k = (long)(rng() >> 1);
    std::map<long, long> tree;
    std::unordered_map<long, long> hash;
    for (long k : keys) { tree[k] = k; hash[k] = k; }
    std::shuffle(keys.begin(), keys.end(), rng);
    const long Q = 1'000'000;
    double tMap  = nsPerOp(Q, [&](long i) { sink = tree.find(keys[i % n])->second; });
    double tHash = nsPerOp(Q, [&](long i) { sink = hash.find(keys[i % n])->second; });
    std::printf("%8ld 个键：map %6.1f ns，unordered_map %5.1f ns\n", n, tMap, tHash);
}

int main() {
    // 1. 有序 map 与哈希表：随机查找。规模不同，差距也不同
    lookupBench(1'000);
    lookupBench(1'000'000);

    // 2. 结构体数组与指针数组：分配 + 遍历 N 个元素
    const long N = 1'000'000;
    struct Order { long id, qty, price; };
    double tPtr = nsPerOp(10, [&](long) {
        std::vector<std::unique_ptr<Order>> v;
        v.reserve(N);
        for (long i = 0; i < N; i++) v.push_back(std::make_unique<Order>(Order{i, 1, 2}));
        long s = 0; for (auto& o : v) s += o->qty * o->price;
        sink = s;
    }) / N;
    double tVal = nsPerOp(10, [&](long) {
        std::vector<Order> v;
        v.reserve(N);
        for (long i = 0; i < N; i++) v.push_back(Order{i, 1, 2});
        long s = 0; for (auto& o : v) s += o.qty * o.price;
        sink = s;
    }) / N;
    std::printf("vector<unique_ptr<Order>>：%5.1f ns / 元素\n", tPtr);
    std::printf("vector<Order>：            %5.1f ns / 元素\n", tVal);

    // 3. 一条关闭的 debug 日志：改前 vs 改后
    OldLogger oldLog;
    LogChannel ch;
    double tOld = nsPerOp(N, [&](long i) { oldLog.log(kDebug, "kv.get", "lookup key=" + std::to_string(i)); });
    double tNew = nsPerOp(N, [&](long i) {
        if (ch.enabled(kDebug)) sink = (long)("lookup key=" + std::to_string(i)).size();
    });
    std::printf("关闭的日志，改前：%5.1f ns\n", tOld);
    std::printf("关闭的日志，改后：%5.1f ns\n", tNew);
}