C++ 高效统计函数运行时间

在C++中，可以使用多种方式统计函数运行时间，虽然不像Java中可以通过注解来实现，但C++的灵活性可以让我们轻松编写一个高效的工具来统计函数运行时间。最常用的方式之一是使用C++标准库中的<chrono>库，它提供了高精度的计时功能。

可以写一个小工具类或者宏，来方便随时统计函数的执行时间。

方法1：使用 std::chrono 手动统计

我们可以使用std::chrono::high_resolution_clock来记录函数开始和结束的时间，并计算时间差。

#include <iostream>
#include <chrono>

void someFunction() {
    // 模拟一些计算任务
    for (int i = 0; i < 1000000; ++i);
}

int main() {
    // 获取当前时间，作为开始时间
    auto start = std::chrono::high_resolution_clock::now();

    // 调用需要统计时间的函数
    someFunction();

    // 获取结束时间
    auto end = std::chrono::high_resolution_clock::now();

    // 计算时间差，单位是微秒
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    std::cout << "函数运行时间: " << duration << " 微秒" << std::endl;

    return 0;
}

这种方式可以灵活地在任何地方使用，但需要手动插入开始和结束时间的获取语句。

方法2：封装到RAII类中

可以通过RAII（资源获取即初始化）模式创建一个定时器类，在创建时开始计时，在析构时打印运行时间，这样可以自动化函数运行时间的统计。

#include <iostream>
#include <chrono>

class Timer {
public:
    Timer(const std::string& name) : name_(name), start_(std::chrono::high_resolution_clock::now()) {}

    ~Timer() {
        auto end = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start_).count();
        std::cout << name_ << " 运行时间: " << duration << " 微秒" << std::endl;
    }

private:
    std::string name_;
    std::chrono::time_point<std::chrono::high_resolution_clock> start_;
};

void someFunction() {
    Timer timer("someFunction");
    for (int i = 0; i < 1000000; ++i);
}

int main() {
    someFunction();
    return 0;
}

这样每次调用Timer类实例时，它会自动统计函数的执行时间并在作用域结束时打印，非常适合统计局部代码段的执行时间。

方法3：使用宏

可以通过宏实现更简洁的方式，无需手动编写类实例，只要在代码中插入宏调用即可统计时间。

#include <iostream>
#include <chrono>

#define TIME_FUNCTION(name) Timer timer##__LINE__(name);

class Timer {
public:
    Timer(const std::string& name) : name_(name), start_(std::chrono::high_resolution_clock::now()) {}

    ~Timer() {
        auto end = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start_).count();
        std::cout << name_ << " 运行时间: " << duration << " 微秒" << std::endl;
    }

private:
    std::string name_;
    std::chrono::time_point<std::chrono::high_resolution_clock> start_;
};

void someFunction() {
    TIME_FUNCTION("someFunction");
    for (int i = 0; i < 1000000; ++i);
}

int main() {
    someFunction();
    return 0;
}

通过这个宏，只需要在函数或者代码块的开头调用 TIME_FUNCTION("name")，它会自动生成定时器并在作用域结束时输出时间，非常简洁。

总结

1. 手动计时：灵活，但代码冗余较多。
2. RAII定时器类：可以自动化统计时间，推荐使用。
3. 宏：最简洁的方法，方便直接在代码中随处使用。

a. 你想要封装更复杂的时间统计工具，比如统计多次函数运行的平均时间吗？
b. 是否希望将这些统计结果保存到日志文件中？

为了解决 a.（统计多次函数运行的平均时间）和 b.（将统计结果保存到日志文件中），我们可以对之前的代码进行扩展：

1. 统计多次函数运行的平均时间：需要在一个函数多次运行时，记录每次的运行时间，并计算出平均时间。
2. 保存到日志文件：可以通过<fstream>库将统计的运行时间结果输出到一个日志文件中。

接下来，我将给出一个完整的C++实现，包含这两个功能。

详细步骤

1. 封装定时器类：扩展之前的Timer类，允许记录多次执行时间，并计算平均值。
2. 保存到日志文件：使用std::ofstream将结果保存到日志文件中。
3. 自动统计运行时间：每次函数运行时自动记录时间，运行结束时计算总的运行次数和平均时间，并将结果输出到日志。

完整代码实现

#include <iostream>
#include <chrono>
#include <fstream>
#include <vector>
#include <string>

// 定时器类，用于多次统计函数运行时间
class Timer {
public:
    Timer(const std::string& name, const std::string& log_file = "log.txt")
        : name_(name), log_file_(log_file), start_(std::chrono::high_resolution_clock::now()), total_duration_(0), run_count_(0) {}

    // 记录单次运行时间
    void start() {
        start_ = std::chrono::high_resolution_clock::now();
    }

    void stop() {
        auto end = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start_).count();
        durations_.push_back(duration);
        total_duration_ += duration;
        ++run_count_;
    }

    // 输出运行时间到控制台并保存到日志文件
    void logResults() {
        if (run_count_ > 0) {
            double average_duration = static_cast<double>(total_duration_) / run_count_;
            std::cout << name_ << " 总运行次数: " << run_count_ << ", 平均运行时间: " << average_duration << " 微秒" << std::endl;

            // 将结果保存到日志文件
            std::ofstream log(log_file_, std::ios_base::app);
            if (log.is_open()) {
                log << name_ << " 总运行次数: " << run_count_ << ", 平均运行时间: " << average_duration << " 微秒\n";
                log.close();
            } else {
                std::cerr << "无法打开日志文件: " << log_file_ << std::endl;
            }
        }
    }

private:
    std::string name_;
    std::string log_file_;
    std::chrono::time_point<std::chrono::high_resolution_clock> start_;
    std::vector<long long> durations_;
    long long total_duration_;
    int run_count_;
};

// 模拟的函数
void someFunction() {
    // 模拟计算任务
    for (int i = 0; i < 1000000; ++i);
}

int main() {
    // 创建一个定时器，统计 someFunction 的运行时间
    Timer timer("someFunction", "performance_log.txt");

    // 模拟多次调用函数
    for (int i = 0; i < 5; ++i) {
        timer.start();  // 开始计时
        someFunction(); // 调用要统计的函数
        timer.stop();   // 停止计时
    }

    // 输出统计结果并写入日志
    timer.logResults();

    return 0;
}

解释

1. 类设计：

   • Timer类用于计时，支持多次运行统计。
   • start()和stop()方法分别用于开始和停止计时，每次停止计时时将该次运行时间记录到durations_中，并更新总的运行时间和运行次数。
   • logResults()方法用于计算平均时间，并将结果输出到控制台，同时保存到日志文件中。

2. 日志保存：

   • 使用std::ofstream将运行结果追加到一个日志文件中，日志文件的名称可以通过构造函数参数指定（默认值为log.txt）。

3. 函数运行时间统计：

   • 通过在循环中多次调用timer.start()和timer.stop()来模拟函数的多次执行，最后通过logResults()输出总运行次数和平均运行时间。

输出示例（控制台和日志文件中的输出相同）

someFunction 总运行次数: 5, 平均运行时间: 1089.6 微秒

日志文件performance_log.txt中的内容：

someFunction 总运行次数: 5, 平均运行时间: 1089.6 微秒

改进方向建议

a. 你是否希望进一步优化性能监控工具，比如增加对其他时间单位（如毫秒或秒）的支持？
b. 需要增强日志的格式化输出，或者将日志输出到其他地方（如数据库）吗？