Question

来自python我试图找到一种方法来计算c ++代码中的几个函数调用。到目前为止我正在使用它。

 void my_func(/*some args*/) {
   clock_t t_begin = std::clock();
   // code
   clock_t t_end = std::clock();
   double elapsed_secs_U = double(t_end - t_begin) / CLOCKS_PER_SEC;
 }

但这是高度重复的。我希望有类似函数包装器的东西，以便我可以写：

 void timer(func, *args) {
   clock_t t_begin = std::clock();
   func(*args)
   clock_t t_end = std::clock();
   double elapsed_secs_U = double(t_end - t_begin) / CLOCKS_PER_SEC;
 }

可以像：

一样使用

 timer(compute_a, a, b)
 timer(compute_b, b, c)

有没有办法在C ++中实现这个目标？

PS：我需要高效运行的时间，因此我不想用分析标志重新编译我的代码并将其粘贴到Valgrind或任何其他工具

Answer 1

使用可变参数模板，您可以执行以下操作：

template <typename F, typename ... Ts>
void timer(F f, Ts&&...args) {
   clock_t t_begin = std::clock();
   f(std::forward<Ts>(args)...);
   clock_t t_end = std::clock();
   double elapsed_secs_U = double(t_end - t_begin) / CLOCKS_PER_SEC;
}

但只是

template <typename F>
void timer(F f) {
   clock_t t_begin = std::clock();
   f();
   clock_t t_end = std::clock();
   double elapsed_secs_U = double(t_end - t_begin) / CLOCKS_PER_SEC;
}

应该完成这项工作，并在需要传递参数时传递捕获lambda：

timer([&](){ compute_b(b, c);});

Answer 2

我过去曾使用过这种模式。这将捕获函数在整个程序生命周期中花费的总时间，而不是一次调用所花费的时间。

struct FunctionTimer
{
    FunctionTimer(std::string const& fname) : fname_(fname), totalTime_(0) {}

    ~FunctionTimer()
    {
       std::cout << "Total time in " << fname_ << ": " << totalTime_ << std::endl;
    }

    std::string fname_;
    double totalTime_;
};

struct TimeAccumulator
{
    TimeAccumulator(FunctionTimer& timer) : timer_(timer), begin_(std::clock()) {}
    ~TimeAccumulator()
    {
       clock_t end = std::clock();
       double elapsed_secs = double(end - begin_) / CLOCKS_PER_SEC;
       timer_.totalTime_ += elapsed_secs;
    }

    clock_t begin_;
    FunctionTimer& timer_;
};

void my_func(/*some args*/)
{
   static FunctionTimer timer("my_func");
   TimeAccumulator acc(timer);

   // code
}

如果您想为计时目的创建一个包装器函数并保持其余的功能不受影响，那么一些模板魔术可能可以解决这个问题。我必须考虑如何实现这样一个功能模板的细节。

多个函数调用的时间

2 个答案: