test.hpp

// fixed-size memory pool 测试程序
#include "memory.hpp"
#include <chrono>
#include <vector>
#include <cstdlib>
#include <iostream>
#include <cstring>
#include <iomanip>
#include <fstream>
#include <random>
#include <algorithm>
#include <cstdio>
#include <thread>
#include <cassert>
#include <future>

/*  ================== 宏常量 ==================  */
constexpr std::size_t ALLOC_COUNT = 1'000;
constexpr std::size_t BLOCK_SIZE    = 64;        // 单块字节数
constexpr std::size_t WARMUP_COUNT  = 100;       // 预热次数，防止冷缓存干扰
constexpr std::size_t BLOCKS_PER_PAGE = 1024;   // 每页内存块数量
constexpr std::size_t THREADS         = 16;        // 并发线程数
constexpr std::size_t ITERS           = 1'000'000;     // 每线程操作次数

/*  ================== 工具：毫秒计时器 ==================  */
template<typename Func>
double measure_ms(Func&& f) {
    // 起点时间
    auto t0 = std::chrono::high_resolution_clock::now();
    // 执行待测的lambda
    f();
    // 终点时间
    auto t1 = std::chrono::high_resolution_clock::now();
    // 终点减去起点
    std::chrono::duration<double, std::milli> elapsed = t1 - t0;
    // 返回毫秒
    return elapsed.count();
}

/*  ================== 1. 基本功能冒烟测试 ==================  */
void test_basic() {
    std::cout << "[TEST1] 基本功能校验...\n";

    FixedSizeMemory pool(BLOCK_SIZE);           // 建立池
    std::vector<void*> ptrs;                    // 保存分配出的指针
    ptrs.reserve(10);

    // 连续分配十次
    for (int i = 0; i < 10; ++i) {
        void* p = pool.allocate();
        if (!p) { std::cerr << "allocate 返回空指针！\n"; std::exit(1); }
        ptrs.push_back(p);
    }

    // 检验内存可写
    for (void* p : ptrs) {
        std::memset(p, 0xAB, BLOCK_SIZE);
    }

    // 回收所有内存块
    for (void* p : ptrs) pool.deallocate(p);

    // 再分配一次，应该拿到刚才回收的首块（LIFO）
    void* p1 = pool.allocate();
    void* p2 = pool.allocate();
    if (p1 != ptrs.back() || p2 != ptrs[ptrs.size()-2])
        std::cerr << "警告：空闲链表顺序非严格 LIFO（仍合法）\n";

    pool.deallocate(p1);
    pool.deallocate(p2);

    std::cout << "        基本功能校验通过 ✔\n\n";
}

/*  ================== 2. 性能压测：pool vs malloc ==================  */
void test_performance() {
    std::cout << "[TEST2] 性能对比 (" << ALLOC_COUNT << " 次 alloc+free)\n";

    FixedSizeMemory pool(BLOCK_SIZE);

    /* -------- 2.1 内存池 -------- */
    double t_pool = measure_ms([&]() {
        std::vector<void*> ptrs;
        ptrs.reserve(ALLOC_COUNT);
        for (std::size_t i = 0; i < ALLOC_COUNT; ++i)
            ptrs.push_back(pool.allocate());
        for (void* p : ptrs)
            pool.deallocate(p);
    });

    /* -------- 2.2 标准 malloc/free -------- */
    double t_malloc = measure_ms([&]() {
        std::vector<void*> ptrs;
        ptrs.reserve(ALLOC_COUNT);
        for (std::size_t i = 0; i < ALLOC_COUNT; ++i)
            ptrs.push_back(std::malloc(BLOCK_SIZE));
        for (void* p : ptrs)
            std::free(p);
    });

    /* 打印结果 */
    std::cout << "        memory_pool 耗时: " << std::fixed << std::setprecision(2)
              << t_pool   << " ms\n";
    std::cout << "        malloc/free  耗时: " << t_malloc << " ms\n";
    std::cout << "        加速比: " << (t_malloc / t_pool) << "x\n\n";
}


/* ================== 空间性能测试 ================== */
void test_space() {
    std::cout << "[TEST3] 空间性能测试\n";

    constexpr std::size_t REQ_SIZE = 60;
    FixedSizeMemory pool(REQ_SIZE);

    const std::size_t real_block     = pool.block_size();
    const std::size_t meta_per_block = sizeof(FixedSizeMemory::Node);
    const std::size_t page_blocks    = pool.get_blocks_per_page();
    const std::size_t page_bytes     = real_block * page_blocks;

    std::cout << "        请求块大小: " << REQ_SIZE << " B\n";
    std::cout << "        对齐后块大小: " << real_block << " B\n";
    std::cout << "        元数据/块: " << meta_per_block << " B\n";
    std::cout << "        每页块数: " << page_blocks << '\n';
    std::cout << "        每页字节: " << page_bytes << " B ("
              << page_bytes / 1024.0 << " KiB)\n";

    const double internal_frag = 100.0 * (real_block - REQ_SIZE) / real_block;
    const double meta_overhead = 100.0 * meta_per_block / real_block;
    std::cout << "        内部碎片率: " << std::fixed << std::setprecision(2)
              << internal_frag << "%\n";
    std::cout << "        元数据比例: " << meta_overhead << "%\n";

    /* RSS 采样（Linux） */
    auto rss_now = []() -> std::size_t {
    #if defined(__linux__)
        std::ifstream f("/proc/self/status");
        std::string line;
        while (std::getline(f, line))
            if (line.rfind("VmRSS:", 0) == 0) {
                std::size_t kb = 0;
                std::sscanf(line.c_str(), "VmRSS: %zu kB", &kb);
                return kb;
            }
    #endif
        return 1;                     // 保底 1 KiB
    };

    const std::size_t baseline = rss_now();

    /* 强制缺页：让 1 MiB 真正驻留 */
    volatile char sink = 0;
    constexpr std::size_t TEST_PAGES = 16;
    std::vector<void*> ptrs;
    ptrs.reserve(TEST_PAGES * page_blocks);
    for (std::size_t i = 0; i < TEST_PAGES * page_blocks; ++i) {
        void* p = pool.allocate();
        ptrs.push_back(p);
        sink += static_cast<char*>(p)[0];   // touch 第一字节
    }
    (void)sink;

    const std::size_t after_alloc = rss_now();
    const std::size_t pool_rss_kb = (after_alloc > baseline) ? after_alloc - baseline : 1;
    std::cout << "        分配后RSS增量: " << pool_rss_kb / 1024.0 << " KiB\n";
    std::cout << "        每MiB可管理对象: "
              << (ptrs.size() * real_block) / ((pool_rss_kb / 1024.0) + 0.01) << " 个\n";

    /* 外部碎片：随机释放 50 % 再分配同样数量 */
    std::mt19937 rng(42);
    std::shuffle(ptrs.begin(), ptrs.end(), rng);
    for (std::size_t i = 0; i < ptrs.size() / 2; ++i) pool.deallocate(ptrs[i]);
    ptrs.erase(ptrs.begin(), ptrs.begin() + ptrs.size() / 2);

    const std::size_t refill_cnt = ptrs.size();
    for (std::size_t i = 0; i < refill_cnt; ++i)
        ptrs.push_back(pool.allocate());

    const std::size_t after_refill = rss_now();
    const std::size_t delta_kb = (after_refill > after_alloc) ? after_refill - after_alloc : 0;
    std::cout << "        随机释放再分配后RSS增量: " << delta_kb << " KiB (0 表示无外部碎片)\n";

    for (void* p : ptrs) pool.deallocate(p);
    std::cout << "        空间体检完成 ✔\n\n";
}




/*  ================== 3. 边界场景 ==================  */
void test_edge() {
    std::cout << "[TEST4] 边界场景...\n";

    /* 3.1 极小 block */
    {
        FixedSizeMemory tiny_pool(1);               // 1 字节请求
        void* p = tiny_pool.allocate();
        if (!p) { std::cerr << "1 字节分配失败\n"; std::exit(1); }
        tiny_pool.deallocate(p);
        std::cout << "        1 字节块 通过 ✔\n";
    }

    /* 3.2 空指针回收（应不崩溃） */
    {
        FixedSizeMemory pool(32);
        pool.deallocate(nullptr);                   // 应安全返回
        std::cout << "        空指针回收 通过 ✔\n";
    }

    std::cout << '\n';
}

/*  ================== 4. 打印池内部状态（辅助调试） ==================  */
void print_pool_stat(const FixedSizeMemory& pool) {
    std::cout << "        单块大小（对齐后）: " << pool.get_blocks_size() << " B\n";
    std::cout << "        每页块数: " << pool.get_blocks_per_page() << '\n';
}

/*=====================5. 多线程高并测试 =================*/

void test_thread_safety() {
    std::cout << "[TEST5] 线程安全测试...\n";
    const size_t block_size = 64;
    const size_t blocks_per_page = 1024;
    FixedSizeMemory memory_pool(block_size, blocks_per_page);

    const int num_threads = 8;
    const int allocations_per_thread = 10000;

    std::vector<std::thread> threads;
    std::vector<std::vector<void*>> allocated_ptrs(num_threads);

    auto start = std::chrono::high_resolution_clock::now();

    // 启动多线程并发分配/释放
    for (int t = 0; t < num_threads; ++t) {
        threads.emplace_back([&, t, allocations_per_thread]() {
            std::random_device rd;
            std::mt19937 gen(rd() + t);
            std::uniform_int_distribution<> dis(0, 1);

            std::vector<void*>& thread_ptrs = allocated_ptrs[t];
            thread_ptrs.reserve(allocations_per_thread);

            int allocated_count = 0;

            for (int i = 0; i < allocations_per_thread; ++i) {
                if (dis(gen) == 0 || allocated_count == 0) {
                    // 分配内存
                    void* ptr = memory_pool.allocate();
                    if (ptr != nullptr) {
                        memset(ptr, t + 1, std::min(block_size, static_cast<size_t>(64)));
                        thread_ptrs.push_back(ptr);
                        allocated_count++;
                    }
                } else {
                    // 释放内存
                    if (!thread_ptrs.empty()) {
                        void* ptr = thread_ptrs.back();
                        thread_ptrs.pop_back();
                        memory_pool.deallocate(ptr);
                        allocated_count--;
                    }
                }
            }

            // 释放本线程剩余的所有内存块
            while (!thread_ptrs.empty()) {
                void* ptr = thread_ptrs.back();
                thread_ptrs.pop_back();
                memory_pool.deallocate(ptr);
            }
            memory_pool.flush_thread_cache(); // 显式调用
        });
    }

    // 等待所有线程完成
    for (auto& thread : threads) {
        thread.join();
    }

    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);

    // ====== 输出多线程测试结果 ======
    std::cout << "总耗时: " << duration.count() << " ms\n";
    std::cout << "内存块大小: " << memory_pool.get_blocks_size() << " bytes\n";
    std::cout << "每页内存块数量: " << memory_pool.get_blocks_per_page() << "\n";
    std::cout << "总页数: " << memory_pool.page_count() << "\n";
    std::cout << "当前已分配内存块数: " << memory_pool.allocated_count() << "\n";
    std::cout << "当前空闲内存块数: " << memory_pool.free_count() << "\n";

    bool multi_thread_pass = (memory_pool.allocated_count() == 0);
    if (multi_thread_pass) {
        std::cout << "✓ 多线程测试通过：所有内存块均已正确释放！\n";
    } else {
        std::cout << "✗ 多线程测试失败：仍有 " << memory_pool.allocated_count() << " 个内存块未释放！\n";
        assert(false && "多线程内存泄漏检测失败");
    }

    // ====== 单线程功能验证（必须在 join 之后）======
    std::cout << "\n执行单线程功能验证...\n";
    std::vector<void*> test_ptrs;
    const int single_thread_allocs = 1000;

    for (int i = 0; i < single_thread_allocs; ++i) {
        void* ptr = memory_pool.allocate();
        if (!ptr) {
            std::cerr << "✗ 单线程分配失败！\n";
            assert(false);
        }
        test_ptrs.push_back(ptr);
        memset(ptr, i & 0xFF, std::min(block_size, static_cast<size_t>(64)));
    }

    for (void* ptr : test_ptrs) {
        memory_pool.deallocate(ptr);
    }
    test_ptrs.clear();


    // [新增]：强制刷新主线程的本地缓存，确保释放的块归还给全局池
    memory_pool.flush_thread_cache();

    bool single_thread_pass = (memory_pool.allocated_count() == 0);
    if (single_thread_pass) {
        std::cout << "✓ 单线程功能验证通过！\n";
    } else {
        std::cout << "✗ 单线程功能验证失败！\n";
        assert(false && "单线程验证失败");
    }

    // ====== 最终测试总结 ======
    std::cout << "\n线程安全测试总结：\n";
    std::cout << "- 并发线程数: " << num_threads << "\n";
    std::cout << "- 每线程操作次数: " << allocations_per_thread << "（混合分配/释放）\n";
    std::cout << "- 总操作次数: " << num_threads * allocations_per_thread << "\n";
    std::cout << "- 内存池最终状态: "
              << (memory_pool.allocated_count() == 0 ? "干净（无泄漏）" : "存在泄漏") << "\n";
    std::cout << "- 测试结果: " << (multi_thread_pass && single_thread_pass ? "PASS" : "FAIL") << "\n";
    std::cout << "=====================================\n";
}

void benchmark_per_page_locking_safe() {
    constexpr std::size_t BLOCK_SIZE       = 64;          // 内存块大小
    constexpr std::size_t BLOCKS_PER_PAGE  = 1024;        // 每页块数
    constexpr std::size_t THREADS          = 16;          // 线程数
    constexpr std::size_t ITERS            = 100000;      // 每线程分配+释放次数

    std::cout << "==================================================\n";
    std::cout << "   Safe Benchmark: Per-Page Locking Memory Pool\n";
    std::cout << "==================================================\n";
    std::cout << "Block size     : " << BLOCK_SIZE << " bytes\n";
    std::cout << "Blocks per page: " << BLOCKS_PER_PAGE << "\n";
    std::cout << "Threads        : " << THREADS << "\n";
    std::cout << "Ops per thread : " << (ITERS * 2) << " (alloc + dealloc)\n";
    std::cout << "Total ops      : " << (THREADS * ITERS * 2) << "\n";
    std::cout << "--------------------------------------------------\n";

    // 创建内存池（现在析构是安全的！）
    auto pool = std::make_unique<FixedSizeMemory>(BLOCK_SIZE, BLOCKS_PER_PAGE);

    // 工作 lambda：每个线程执行分配和释放
    auto worker = [pool_ptr = pool.get(), ITERS]() -> double {
        std::vector<void*> ptrs;
        ptrs.reserve(ITERS);

        auto start = std::chrono::steady_clock::now();

        // 分配阶段
        for (std::size_t i = 0; i < ITERS; ++i) {
            void* p = pool_ptr->allocate();
            if (!p) {
                std::cerr << "Allocation failed in thread!\n";
                std::abort();
            }
            ptrs.push_back(p);
        }

        // 释放阶段
        for (std::size_t i = 0; i < ITERS; ++i) {
            pool_ptr->deallocate(ptrs[i]);
        }

        // [新增]：在线程结束前，手动将本地缓存归还给 Page
        // 这样可以避免线程退出时 Janitor 析构带来的时序问题，并确保计数归零（虽然此处不查计数）
        pool_ptr->flush_thread_cache();
         
        auto end = std::chrono::steady_clock::now();
        return std::chrono::duration<double>(end - start).count();
    };

    // 启动所有线程（使用 async 确保并行）
    std::vector<std::future<double>> results;
    const auto start_time = std::chrono::steady_clock::now();

    for (std::size_t i = 0; i < THREADS; ++i) {
        results.emplace_back(std::async(std::launch::async, worker));
    }

    // 等待所有线程完成（此时 pool 尚未析构）
    double total_thread_time = 0.0;
    double max_time = 0.0;
    for (auto& fut : results) {
        double t = fut.get();
        total_thread_time += t;
        if (t > max_time) max_time = t;
    }

    const auto end_time = std::chrono::steady_clock::now();
    const double wall_time = std::chrono::duration<double>(end_time - start_time).count();
    const std::size_t total_ops = THREADS * ITERS * 2;

    // 计算性能指标
    const double throughput_mops = static_cast<double>(total_ops) / wall_time / 1'000'000.0;
    const double avg_latency_ns  = (wall_time / total_ops) * 1'000'000'000.0;

    // 输出结果
    std::cout << "Wall-clock time : " << std::fixed << std::setprecision(6)
              << wall_time << " s\n";
    std::cout << "Max thread time : " << std::fixed << std::setprecision(6)
              << max_time << " s\n";
    std::cout << "Throughput      : " << std::fixed << std::setprecision(2)
              << throughput_mops << " M ops/s\n";
    std::cout << "Avg latency     : " << std::fixed << std::setprecision(2)
              << avg_latency_ns << " ns/op\n";
    std::cout << "==================================================\n";

    pool.reset(); // 或自然析构
}