如何确保在测量时间时呼叫没有被优化掉？

Question

我写了一个函数模板来测量时间：

#include <ctime>
template <typename FUNCTION,typename INPUT,int N>
double measureTime(FUNCTION f,INPUT inp){
  // double x;
  double duration = 0;
  clock_t begin = clock();
  for (int i=0;i<N;i++){
      // x = f(inp);  
      f(inp);
  }
  clock_t end = clock();
  // std::cout << x << std::endl;
  return double(end-begin) / CLOCKS_PER_SEC;
}

我是这样使用它的：

#include <iostream>
typedef std::vector<double> DVect;
double passValue(DVect a){
    double sum = 0;
    for (int i=0;i<a.size();i++){sum += sum+a[i];}
    return sum;
}
typedef double (*passValue_type)(DVect);

int main(int argc, char *argv[]) {
    const int N = 1000;
    const int size = 10000;
    std::vector<double> v(size,0);
    std::cout << measureTime<passValue_type,DVect,N>(passValue,v) << std::endl;
}

目的是可靠地测量不同功能的 CPU 时间，例如值传递与引用传递。实际上，它似乎工作得很好，但是，有时结果时间太短而无法测量，结果我只得到 0。为了确保调用该函数，我打印了调用的结果（参见上面代码中的 cmets）。这是我想避免的，我想让模板尽可能简单，所以我的问题是：

我怎样才能确保函数真的被调用并且没有被优化掉（因为没有使用返回值）？

Answer 1

我通常会这样做：

#include <ctime>

template <typename FUNCTION,typename INPUT,int N>
double measureTime(FUNCTION f,INPUT inp){
  double x = 0;
  double duration = 0;
  clock_t begin = clock();
  for (int i=0;i<N;i++){
      x += f(inp);  
  }
  clock_t end = clock();
  std::cout << x << std::endl;
  // or if (x < 0) cout << x; or similar.
  // such that it doesn't ACTUALLY print anything.
  return double(end-begin) / CLOCKS_PER_SEC;
}

以上假设f 实际上做了一些编译器无法弄清楚如何简化的不平凡的事情。如果f 是return 6;，那么编译器会将其转换为x = 6 * N;，这样运行时间确实很短。

如果你想能够使用“任何”功能，你将不得不做一些更聪明的事情：

template <typename FUNCTION,typename INPUT,int N, typename RET>
double measureTime(FUNCTION f,INPUT inp){
  RET x = 0;
  double duration = 0;
  clock_t begin = clock();
  for (int i=0;i<N;i++){
      x += f(inp);  
  }
  clock_t end = clock();
  std::cout << x << std::endl;
  return double(end-begin) / CLOCKS_PER_SEC;
}

template <typename FUNCTION,typename INPUT,int N, void>
double measureTime(FUNCTION f,INPUT inp){
  clock_t begin = clock();
  for (int i=0;i<N;i++){
      f(inp);  
  }
  clock_t end = clock();
  return double(end-begin) / CLOCKS_PER_SEC;
}

[我还没有真正编译上面的代码，所以它可能有一些小缺陷，但作为一个概念它应该可以工作]。

由于任何有意义的void 函数都必须做一些影响周围世界的事情（输出到流、更改全局变量或调用某个系统调用），因此它不会被消除。当然，调用空函数或类似函数很可能会造成麻烦。

另一种方法，假设您不关心不内联调用是实际将被测函数放在单独的文件中，而不是让编译器从测量时间的代码中“看到”该函数 [而不是使用-flto 允许它在链接时内联函数] - 这样，编译器就无法知道被测函数在做什么，也不会消除调用。

应该注意的是，除了“使编译器不可能知道函数的结果是什么”（例如使用 random /externally sourced input），或“不要让编译器知道函数的作用”。

Answer 2

无内联：确保函数调用和函数定义位于单独的编译单元（即 cpp 文件）中，然后在您的构建中禁用 link-time optimization。

在这种情况下，由于编译单元在 C++ 中的工作方式，编译器将无法内联您的函数调用。此外，编译器将无法完全删除调用。事实上，在优化调用的那一刻，它对你的函数一无所知（除了签名）。

内联：如果您想使用内联函数调用来测量时间，上述简单方法将不起作用。在这种情况下，您必须确保：对于函数内的每个操作，都有一些依赖于它的 observable behavior。例如，您可以将结果写入volatile 变量，或计算结果的一些总和/哈希并将其打印到标准输出。

Answer 3

许多编译器都有扩展来禁用函数的内联。对于 gcc，它是__attribute__((noinline))，例如：

__attribute__((noinline)) void foo() { ... }

Boost 提供了一个可移植的BOOST_NOINLINE 宏。