benchmark_AfterImage.cpp

#include "AfterImage.h"
#include <chrono>
#include <iostream>
#include <random>
#include <vector>

// 生成随机数据
std::vector<std::pair<double, double>> generate_test_data(size_t size) {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<> value_dist(0.0, 100.0);
    std::uniform_real_distribution<> time_dist(0.0, 1000.0);

    std::vector<std::pair<double, double>> data;
    data.reserve(size);

    for (size_t i = 0; i < size; ++i) {
        data.emplace_back(value_dist(gen), time_dist(gen));
    }

    return data;
}

// 测试单个数据流的性能
void benchmark_single_stream(size_t data_size) {
    auto data = generate_test_data(data_size);

    // 预热
    incStat stat(0.1, "test1", 0.0);
    for (size_t i = 0; i < 1000; ++i) {
        stat.insert(data[i].first, data[i].second);
    }

    // 实际测试
    auto start = std::chrono::high_resolution_clock::now();
    for (size_t i = 1000; i < data_size; ++i) {
        stat.insert(data[i].first, data[i].second);
        stat.mean();
        stat.var();
        stat.std();
    }
    auto end = std::chrono::high_resolution_clock::now();

    auto duration =
        std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "C++ Single Stream (" << data_size
              << " records): " << duration.count() << "ms" << std::endl;
}

// 测试协方差计算的性能
void benchmark_covariance(size_t data_size) {
    auto data1 = generate_test_data(data_size);
    auto data2 = generate_test_data(data_size);

    incStat stat1(0.1, "test1", 0.0);
    incStat stat2(0.1, "test2", 0.0);
    incStat_cov cov(&stat1, &stat2, 0.0);

    // 预热
    for (size_t i = 0; i < 1000; ++i) {
        stat1.insert(data1[i].first, data1[i].second);
        stat2.insert(data2[i].first, data2[i].second);
        cov.update_cov("test1", data1[i].first, data1[i].second);
    }

    // 实际测试
    auto start = std::chrono::high_resolution_clock::now();
    for (size_t i = 1000; i < data_size; ++i) {
        stat1.insert(data1[i].first, data1[i].second);
        stat2.insert(data2[i].first, data2[i].second);
        cov.update_cov("test1", data1[i].first, data1[i].second);
        cov.cov();
        cov.pcc();
    }
    auto end = std::chrono::high_resolution_clock::now();

    auto duration =
        std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "C++ Covariance (" << data_size
              << " records): " << duration.count() << "ms" << std::endl;
}

// 测试数据库操作的性能
void benchmark_database(size_t data_size) {
    auto data = generate_test_data(data_size);
    incStatDB db(1000, 0.1);

    // 预热
    for (size_t i = 0; i < 1000; ++i) {
        db.update("test1", data[i].second, data[i].first);
        db.get_1D_Stats("test1");
    }

    // 实际测试
    auto start = std::chrono::high_resolution_clock::now();
    for (size_t i = 1000; i < data_size; ++i) {
        db.update("test1", data[i].second, data[i].first);
        db.get_1D_Stats("test1");
        db.get_2D_Stats("test1", "test2");
    }
    auto end = std::chrono::high_resolution_clock::now();

    auto duration =
        std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "C++ Database (" << data_size
              << " records): " << duration.count() << "ms" << std::endl;
}

int main() {
    std::vector<size_t> sizes = {10000, 100000, 1000000};

    std::cout << "=== AfterImage Performance Benchmark ===\n" << std::endl;

    for (size_t size : sizes) {
        std::cout << "\nTesting with " << size << " records:" << std::endl;
        benchmark_single_stream(size);
        benchmark_covariance(size);
        benchmark_database(size);
    }

    return 0;
}