可以 std::function 内联还是我应该使用不同的方法？

Question

我正在开发一个复杂的框架，它使用 std::function<> 作为许多函数的参数。通过分析，我发现了以下性能问题之一。

谁能解释一下为什么 Loop3a 这么慢？我预计将使用内联并且时间相同。组装也一样。有什么方法可以提高性能或以不同的方式吗？ C++17 在这方面有什么改变吗？

#include <iostream>
#include <functional>
#include <chrono>
#include <cmath>

static const unsigned N = 300;

struct Loop3a
{
    void impl()
    {
        sum = 0.0;
        for (unsigned i = 1; i <= N; ++i) {
            for (unsigned j = 1; j <= N; ++j) {
                for (unsigned k = 1; k <= N; ++k) {
                    sum +=  fn(i, j, k);
                }
            }
        }
    }

    std::function<double(double, double, double)> fn = [](double a, double b, double c) {
        const auto subFn = [](double x, double y) { return x / (y+1); };
        return sin(a) + log(subFn(b, c));
    };
    double sum;
};


struct Loop3b
{
    void impl()
    {
        sum = 0.0;
        for (unsigned i = 1; i <= N; ++i) {
            for (unsigned j = 1; j <= N; ++j) {
                for (unsigned k = 1; k <= N; ++k) {
                    sum += sin((double)i) + log((double)j / (k+1));
                }
            }
        }
    }

    double sum;
};


int main()
{
    using Clock = std::chrono::high_resolution_clock;
    using TimePoint = std::chrono::time_point<Clock>;

    TimePoint start, stop;
    Loop3a a;
    Loop3b b;

    start = Clock::now();
    a.impl();
    stop = Clock::now();
    std::cout << "A: " << std::chrono::duration_cast<std::chrono::milliseconds>(stop - start).count();
    std::cout << "ms\n";

    start = Clock::now();
    b.impl();
    stop = Clock::now();
    std::cout << "B: " << std::chrono::duration_cast<std::chrono::milliseconds>(stop - start).count();
    std::cout << "ms\n";

    return a.sum == b.sum;
}

使用带有“-O2 -std=c++14”的 g++5.4 的示例输出：

A: 1794ms
B: 906ms

在探查器中，我可以看到很多这样的内部结构：

double&& std::forward<double>(std::remove_reference<double>::type&)
std::_Function_handler<double (double, double, double), Loop3a::fn::{lambda(double, double, double)#1}>::_M_invoke(std::_Any_data const&, double, double, double)
Loop3a::fn::{lambda(double, double, double)#1}* const& std::_Any_data::_M_access<Loop3a::fn::{lambda(double, double, double)#1}*>() const

Answer 1

std::function 不是零运行时成本抽象。它是一个类型擦除的包装器，在调用 operator() 时具有类似 virtual 的调用成本，并且还可能进行堆分配 （这可能意味着每次调用都会丢失缓存）.

编译器很可能无法内联它。

如果您想以不引入额外开销并允许编译器内联的方式存储您的函数对象它，你应该使用一个模板参数。这并不总是可能的，但可能适合您的用例。

我写了一篇与主题相关的文章：
"Passing functions to functions"

它包含一些基准，显示与模板参数和其他解决方案相比，std::function 生成了多少程序集。

Answer 2

std::function大致有虚拟调用开销。这很小，但如果您的操作更小，它可能会很大。

在你的例子中，你在 std::function 上大量循环，用一组可预测的值调用它，并且可能在其中几乎什么都不做。

我们可以解决这个问题。

template<class F>
std::function<double(double, double, double, unsigned)>
repeated_sum( F&& f ) {
  return
    [f=std::forward<F>(f)]
    (double a, double b, double c, unsigned count)
    {
      double sum = 0.0;
      for (unsigned i = 0; i < count; ++i)
        sum += f(a,b,c+i);
      return sum;
    };
}

然后

std::function<double(double, double, double, unsigned)> fn =
  repeated_sum
  (
    [](double a, double b, double c) {
      const auto subFn = [](double x, double y) { return x / (y+1); };
      return sin(a) + log(subFn(b, c));
    }
  );

现在 repeating_function 使用 double, double, double 函数，returns 使用 double, double, double, unsigned。这个新函数重复调用前一个函数，每次最后一个坐标增加1。

然后我们替换impl如下：

void impl()
{
    sum = 0.0;
    for (unsigned i = 1; i <= N; ++i) {
        for (unsigned j = 1; j <= N; ++j) {
            fn(i,j,0,N);
        }
    }
}

我们将 "lowest level loop" 替换为对重复函数的一次调用。

这将使虚拟调用开销减少 300 倍，这基本上使它消失了。基本上，time/300 的 50% = 0.15% 的时间（实际上是 0.3%，因为我们将时间减少了 2 倍，这使贡献增加了一倍，但谁在计算十分之一？）

现在在实际情况下你可能不会用 300 个相邻值来调用它。但通常会有一些规律。

我们上面所做的是移动一些逻辑来控制 fn 在 fn 中的调用方式。如果你能做到这一点，你可以从考虑中删除虚拟调用开销。

std::function 开销几乎可以忽略，除非您想每秒调用它数十亿次，我称之为 "per-pixel" 操作。用 "per-scanline" 替换这样的操作——每行相邻像素——并且开销不再是一个问题。

这可能需要公开有关如何使用函数对象的一些逻辑"in a header"。根据我的经验，仔细选择公开的逻辑可以使其相对通用。

最后，请注意内联 std::function 是可能的，并且编译器在这方面做得越来越好。但它很坚硬，也很脆弱。在这一点上依赖它是不明智的。

还有另一种方法。

template<class F>
struct looper_t {
  F fn;
  double operator()( unsigned a, unsigned b, unsigned c ) const {
    double sum = 0;
    for (unsigned i = 0; i < a; ++i)
      for (unsigned j = 0; j < b; ++j)
        for (unsigned k = 0; k < c; ++k)
          sum += fn(i,j,k);
    return sum;
  }
};
template<class F>
looper_t<F> looper( F f ) {
  return {std::move(f)};
}

现在我们编写循环程序：

struct Loop3c {
  std::function<double(unsigned, unsigned, unsigned)> fn = looper(
    [](double a, double b, double c) {
      const auto subFn = [](double x, double y) { return x / (y+1); };
      return sin(a) + log(subFn(b, c));
    }
  );
  double sum = 0;
  void impl() {
    sum=fn(N,N,N);
  }
};

这会擦除 3 维循环的整个操作，而不仅仅是尾随维度。

可以 std::function 内联还是我应该使用不同的方法？

Can be std::function inlined or should I use different approach?

c++

c++11

std-function

c++14

c++17