Rad*_*dek 2 c++ c++11 std-function c++14 c++17
我正在研究一个复杂的框架,它使用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
std::function是不是一个零运行成本的抽象.它是一个类型擦除的包装器,virtual在调用时具有类似成本的调用,operator()并且还可能进行堆分配(这可能意味着每次调用的缓存未命中).
编译器很可能无法内联它.
如果要以不引入额外开销并允许编译器内联的方式存储函数对象,则应使用模板参数.这并不总是可行,但可能适合您的使用案例.
我写了一篇与主题相关的文章:
"将函数传递给函数"
它包含一些基准测试,显示std::function与模板参数和其他解决方案相比生成的程序集数量.
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函数并返回一个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);
}
}
}
我们用对重复函数的单个调用替换“最低级别循环”。
这会将虚拟调用开销减少 300 倍，基本上使其消失。基本上，50% 的时间/300 = 0.15% 的时间（实际上是 0.3%，因为我们将时间减少了 2 倍，这使贡献加倍，但谁在计算十分之一？）
现在在实际情况下，您可能不会使用 300 个相邻值来调用它。但通常有一些模式。
我们上面所做的是移动一些控制如何fn在内部调用的逻辑fn。如果你能做到这一点，你就可以不考虑虚拟调用的开销。
std::function开销几乎可以忽略，除非您想以每秒数十亿次的数量级调用它，我称之为“每像素”操作。将此类操作替换为“每条扫描线”——每行相邻像素——并且开销不再是一个问题。
这可能需要公开一些关于如何在“标题”中使用函数对象的逻辑。根据我的经验，仔细选择您公开的逻辑可以使其相对通用。
最后，请注意内联是可能的，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 维循环的整个操作，而不仅仅是尾随维度。