# 填充 100 万条记录
./db_bench --benchmarks=fillseq --num=1000000 --value_size=100

# 随机写入测试
./db_bench --benchmarks=fillrandom --num=1000000 --value_size=100

# 随机读取测试
./db_bench --benchmarks=readrandom --num=1000000

# 顺序读取测试
./db_bench --benchmarks=readseq --num=1000000

# 覆盖写测试
./db_bench --benchmarks=overwrite --num=1000000

# 综合测试
./db_bench --benchmarks="fillseq,readseq,fillrandom,readrandom" \
           --num=1000000 --value_size=100

# 顺序写入
./db_bench --benchmarks=fillseq --num=1000000 \
           --value_size=100 --db=/tmp/bench_seq

# 随机写入
./db_bench --benchmarks=fillrandom --num=1000000 \
           --value_size=100 --db=/tmp/bench_random

# 先填充数据
./db_bench --benchmarks=fillrandom --num=1000000 \
           --value_size=100 --db=/tmp/bench_read

# 顺序读取
./db_bench --benchmarks=readseq --num=1000000 \
           --db=/tmp/bench_read --use_existing_db=1

# 随机读取
./db_bench --benchmarks=readrandom --num=1000000 \
           --db=/tmp/bench_read --use_existing_db=1

# 随机读取（带 Bloom Filter）
./db_bench --benchmarks=readrandom --num=1000000 \
           --db=/tmp/bench_read --use_existing_db=1 --bloom_bits=10

# 小缓存
./db_bench --benchmarks=readrandom --num=1000000 \
           --cache_size=8388608 --db=/tmp/bench_smallcache

# 大缓存
./db_bench --benchmarks=readrandom --num=1000000 \
           --cache_size=536870912 --db=/tmp/bench_largecache

# 无压缩
./db_bench --benchmarks="fillseq,readseq" --num=1000000 \
           --compression=0 --db=/tmp/bench_nocomp

# Snappy 压缩
./db_bench --benchmarks="fillseq,readseq" --num=1000000 \
           --compression=1 --db=/tmp/bench_snappy

./db_bench --benchmarks=readrandom --num=1000000 --histogram=1

# 输出类似：
# Percentiles:
#   P50:     3.2 us
#   P99:    12.8 us
#   P99.9:  45.6 us

#include <chrono>
#include <iostream>
#include <random>
#include <vector>
#include "leveldb/db.h"
#include "leveldb/filter_policy.h"
#include "leveldb/statistics.h"

class Benchmark {
public:
    Benchmark(const std::string& db_path,
              size_t cache_size = 128 * 1024 * 1024)
        : db_path_(db_path) {
        leveldb::Options opts;
        opts.create_if_missing = true;
        opts.write_buffer_size = 64 * 1024 * 1024;
        opts.max_open_files = 500;
        opts.filter_policy = leveldb::NewBloomFilterPolicy(10);
        opts.block_cache = leveldb::NewLRUCache(cache_size);
        opts.statistics = leveldb::CreateDBStatistics();
        stats_ = opts.statistics;

        leveldb::Status s = leveldb::DB::Open(opts, db_path_, &db_);
        if (!s.ok()) throw std::runtime_error(s.ToString());
    }

    ~Benchmark() {
        delete db_;
        delete stats_;
    }

    // 顺序写入测试
    void BenchFillSeq(int num, int value_size) {
        std::string value(value_size, 'x');
        auto start = Now();

        for (int i = 0; i < num; i++) {
            char key[32];
            snprintf(key, sizeof(key), "%016d", i);
            db_->Put(leveldb::WriteOptions(), key, value);
        }

        Report("fillseq", num, start);
    }

    // 随机写入测试
    void BenchFillRandom(int num, int value_size) {
        std::string value(value_size, 'x');
        std::mt19937 rng(42);
        auto start = Now();

        for (int i = 0; i < num; i++) {
            char key[32];
            snprintf(key, sizeof(key), "%016d", rng());
            db_->Put(leveldb::WriteOptions(), key, value);
        }

        Report("fillrandom", num, start);
    }

    // 随机读取测试
    void BenchReadRandom(int num) {
        std::mt19937 rng(42);
        std::string value;
        auto start = Now();

        int found = 0;
        for (int i = 0; i < num; i++) {
            char key[32];
            snprintf(key, sizeof(key), "%016d", rng());
            if (db_->Get(leveldb::ReadOptions(), key, &value).ok()) {
                found++;
            }
        }

        Report("readrandom", num, start);
        std::cout << "  Found: " << found << "/" << num << std::endl;
    }

    // 顺序读取测试
    void BenchReadSeq(int num) {
        auto start = Now();
        auto* it = db_->NewIterator(leveldb::ReadOptions());
        int count = 0;
        for (it->SeekToFirst(); it->Valid(); it->Next()) {
            count++;
        }
        delete it;
        Report("readseq", count, start);
    }

    // 批量写入测试
    void BenchWriteBatch(int num, int batch_size, int value_size) {
        std::string value(value_size, 'x');
        auto start = Now();

        for (int i = 0; i < num; i += batch_size) {
            leveldb::WriteBatch batch;
            int end = std::min(i + batch_size, num);
            for (int j = i; j < end; j++) {
                char key[32];
                snprintf(key, sizeof(key), "%016d", j);
                batch.Put(key, value);
            }
            db_->Write(leveldb::WriteOptions(), &batch);
        }

        std::string label = "writebatch_" + std::to_string(batch_size);
        Report(label, num, start);
    }

    // 打印统计信息
    void PrintStats() {
        std::cout << "\n=== Statistics ===" << std::endl;
        std::cout << stats_->ToString() << std::endl;
    }

private:
    using TimePoint = std::chrono::high_resolution_clock::time_point;

    TimePoint Now() {
        return std::chrono::high_resolution_clock::now();
    }

    void Report(const std::string& name, int num, TimePoint start) {
        auto end = Now();
        auto us = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
        double ops_per_sec = (double)num / us.count() * 1e6;
        double us_per_op = (double)us.count() / num;
        std::cout << name << ": "
                  << us_per_op << " us/op; "
                  << ops_per_sec << " ops/s" << std::endl;
    }

    leveldb::DB* db_;
    leveldb::Statistics* stats_;
    std::string db_path_;
};

int main() {
    Benchmark bench("/tmp/custom_bench", 256 * 1024 * 1024);

    int num = 1000000;
    int value_size = 100;

    std::cout << "=== 写入测试 ===" << std::endl;
    bench.BenchFillSeq(num, value_size);
    bench.BenchFillRandom(num, value_size);

    std::cout << "\n=== 读取测试 ===" << std::endl;
    bench.BenchReadRandom(num);
    bench.BenchReadSeq(num);

    std::cout << "\n=== 批量写入测试 ===" << std::endl;
    bench.BenchWriteBatch(num, 100, value_size);
    bench.BenchWriteBatch(num, 1000, value_size);

    bench.PrintStats();
    return 0;
}

for size in 4194304 16777216 67108864 268435456; do
    echo "=== write_buffer_size = $size ==="
    ./db_bench --benchmarks=fillrandom --num=5000000 \
               --write_buffer_size=$size --db=/tmp/bench_wb$size
done

for cache in 8388608 67108864 268435456 1073741824; do
    echo "=== block_cache = $cache ==="
    ./db_bench --benchmarks=readrandom --num=1000000 \
               --cache_size=$cache --use_existing_db=1 \
               --db=/tmp/bench_cache$cache
done

echo "=== 无 Bloom Filter ==="
./db_bench --benchmarks=readrandom --num=1000000 \
           --bloom_bits=0 --db=/tmp/bench_bloom0

echo "=== Bloom Filter 10 bits ==="
./db_bench --benchmarks=readrandom --num=1000000 \
           --bloom_bits=10 --db=/tmp/bench_bloom10

echo "=== Bloom Filter 14 bits ==="
./db_bench --benchmarks=readrandom --num=1000000 \
           --bloom_bits=14 --db=/tmp/bench_bloom14