test_FeatureExtractor.cpp

#include "FeatureExtractor.h"
#include <algorithm>
#include <chrono>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <numeric>

// 测试提取器的基本功能
void test_basic_functionality(const std::string &filepath) {
    std::cout << "===== 测试基本功能 =====" << std::endl;

    try {
        // 创建特征提取器，限制处理10个数据包
        FeatureExtractor fe(filepath, 10);

        // 获取特征数量
        size_t num_features = fe.get_num_features();
        std::cout << "特征数量: " << num_features << std::endl;

        // 处理前5个数据包
        for (int i = 0; i < 5; ++i) {
            std::vector<double> features = fe.get_next_vector();
            if (features.empty()) {
                std::cout << "数据包 #" << i << ": 无特征" << std::endl;
                continue;
            }

            std::cout << "数据包 #" << i << ": 提取了 " << features.size()
                      << " 个特征" << std::endl;

            // 输出前5个特征值
            std::cout << "  前5个特征值: ";
            for (size_t j = 0; j < std::min(size_t(5), features.size()); ++j) {
                std::cout << features[j] << " ";
            }
            std::cout << std::endl;
        }

        std::cout << "基本功能测试完成!" << std::endl;
    } catch (const std::exception &e) {
        std::cerr << "测试失败: " << e.what() << std::endl;
    }
}

// 测试性能
void benchmark_performance(const std::string &filepath, int num_packets) {
    std::cout << "\n===== 性能测试 =====" << std::endl;

    try {
        // 创建特征提取器
        auto start_time = std::chrono::high_resolution_clock::now();
        FeatureExtractor fe(filepath, num_packets);
        auto end_time = std::chrono::high_resolution_clock::now();
        auto init_duration =
            std::chrono::duration_cast<std::chrono::milliseconds>(end_time -
                                                                  start_time)
                .count();

        std::cout << "初始化时间: " << init_duration << " ms" << std::endl;

        // 处理所有数据包并测量时间
        start_time = std::chrono::high_resolution_clock::now();

        std::vector<double> processing_times;
        int processed_packets = 0;
        int feature_dimensions = 0;

        for (int i = 0; i < num_packets; ++i) {
            auto packet_start = std::chrono::high_resolution_clock::now();
            std::vector<double> features = fe.get_next_vector();
            auto packet_end = std::chrono::high_resolution_clock::now();

            if (features.empty()) {
                break;
            }

            double packet_time =
                std::chrono::duration_cast<std::chrono::microseconds>(
                    packet_end - packet_start)
                    .count() /
                1000.0; // 转换为毫秒

            processing_times.push_back(packet_time);
            feature_dimensions = features.size();
            processed_packets++;
        }

        end_time = std::chrono::high_resolution_clock::now();
        auto total_duration =
            std::chrono::duration_cast<std::chrono::milliseconds>(end_time -
                                                                  start_time)
                .count();

        // 计算统计信息
        double avg_time =
            std::accumulate(processing_times.begin(), processing_times.end(),
                            0.0) /
            (processing_times.empty() ? 1 : processing_times.size());

        double min_time = processing_times.empty()
                              ? 0
                              : *std::min_element(processing_times.begin(),
                                                  processing_times.end());

        double max_time = processing_times.empty()
                              ? 0
                              : *std::max_element(processing_times.begin(),
                                                  processing_times.end());

        std::cout << "处理了 " << processed_packets << " 个数据包" << std::endl;
        std::cout << "每个特征向量维度: " << feature_dimensions << std::endl;
        std::cout << "总处理时间: " << total_duration << " ms" << std::endl;
        std::cout << "平均每个数据包处理时间: " << avg_time << " ms"
                  << std::endl;
        std::cout << "最小处理时间: " << min_time << " ms" << std::endl;
        std::cout << "最大处理时间: " << max_time << " ms" << std::endl;
        std::cout << "每秒处理数据包数: "
                  << (1000.0 * processed_packets / total_duration) << std::endl;

        std::cout << "性能测试完成!" << std::endl;
    } catch (const std::exception &e) {
        std::cerr << "测试失败: " << e.what() << std::endl;
    }
}

// 比较Python版本和C++版本的性能
void compare_with_python(const std::string &filepath,
                         const std::string &python_results_file) {
    std::cout << "\n===== 与Python版本比较 =====" << std::endl;

    try {
        // 读取Python版本的性能结果
        std::ifstream python_file(python_results_file);
        if (!python_file.is_open()) {
            std::cerr << "无法打开Python结果文件: " << python_results_file
                      << std::endl;
            return;
        }

        double python_init_time, python_total_time, python_avg_time;
        int python_processed_packets;

        python_file >> python_init_time >> python_total_time >>
            python_avg_time >> python_processed_packets;
        python_file.close();

        // 测量C++版本的性能
        auto start_time = std::chrono::high_resolution_clock::now();
        FeatureExtractor fe(filepath, python_processed_packets);
        auto end_time = std::chrono::high_resolution_clock::now();
        auto init_duration =
            std::chrono::duration_cast<std::chrono::milliseconds>(end_time -
                                                                  start_time)
                .count();

        start_time = std::chrono::high_resolution_clock::now();
        int processed_packets = 0;

        for (int i = 0; i < python_processed_packets; ++i) {
            std::vector<double> features = fe.get_next_vector();
            if (features.empty()) {
                break;
            }
            processed_packets++;
        }

        end_time = std::chrono::high_resolution_clock::now();
        auto total_duration =
            std::chrono::duration_cast<std::chrono::milliseconds>(end_time -
                                                                  start_time)
                .count();

        double avg_time =
            static_cast<double>(total_duration) / processed_packets;

        // 输出比较结果
        std::cout << "Python版本:" << std::endl;
        std::cout << "  初始化时间: " << python_init_time << " ms" << std::endl;
        std::cout << "  总处理时间: " << python_total_time << " ms"
                  << std::endl;
        std::cout << "  平均每个数据包处理时间: " << python_avg_time << " ms"
                  << std::endl;
        std::cout << "  处理了 " << python_processed_packets << " 个数据包"
                  << std::endl;

        std::cout << "C++版本:" << std::endl;
        std::cout << "  初始化时间: " << init_duration << " ms" << std::endl;
        std::cout << "  总处理时间: " << total_duration << " ms" << std::endl;
        std::cout << "  平均每个数据包处理时间: " << avg_time << " ms"
                  << std::endl;
        std::cout << "  处理了 " << processed_packets << " 个数据包"
                  << std::endl;

        // 计算加速比
        double init_speedup = python_init_time / init_duration;
        double total_speedup = python_total_time / total_duration;
        double avg_speedup = python_avg_time / avg_time;

        std::cout << "加速比:" << std::endl;
        std::cout << "  初始化时间加速比: " << init_speedup << "x" << std::endl;
        std::cout << "  总处理时间加速比: " << total_speedup << "x"
                  << std::endl;
        std::cout << "  平均处理时间加速比: " << avg_speedup << "x"
                  << std::endl;

        std::cout << "比较完成!" << std::endl;
    } catch (const std::exception &e) {
        std::cerr << "比较失败: " << e.what() << std::endl;
    }
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        std::cerr << "用法: " << argv[0]
                  << " <pcap/tsv文件路径> [python结果文件]" << std::endl;
        return 1;
    }

    std::string filepath = argv[1];

    // 测试基本功能
    test_basic_functionality(filepath);

    // 测试性能
    benchmark_performance(filepath, 10000);

    // 如果提供了Python结果文件，进行比较
    if (argc >= 3) {
        std::string python_results_file = argv[2];
        compare_with_python(filepath, python_results_file);
    }

    return 0;
}