10

互联网上的一些消息来源（特别是这个）说 std::function 使用小闭包优化，例如，如果闭包大小低于一定数量的数据，它不会分配堆（上面的链接表示 gcc 为 16 个字节）

所以我去挖掘 g++ 标头

看起来是否应用这种优化是由“功能”标头中的这段代码决定的（g ++ 4.6.3）

static void
_M_init_functor(_Any_data& __functor, _Functor&& __f)
{ _M_init_functor(__functor, std::move(__f), _Local_storage()); }

和一些线路：

static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
{ new (__functor._M_access()) _Functor(std::move(__f)); }

static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
{ __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
  };

例如，如果 _Local_storage() 为 true_type，则调用placement-new，否则 - 常规 new

_Local_storage 的定义如下：

typedef integral_constant<bool, __stored_locally> _Local_storage;

和 __stored_locally：

static const std::size_t _M_max_size = sizeof(_Nocopy_types);
static const std::size_t _M_max_align = __alignof__(_Nocopy_types);

static const bool __stored_locally =
(__is_location_invariant<_Functor>::value
 && sizeof(_Functor) <= _M_max_size
 && __alignof__(_Functor) <= _M_max_align
 && (_M_max_align % __alignof__(_Functor) == 0));

最后：__is_location_invariant：

template<typename _Tp>
struct __is_location_invariant
: integral_constant<bool, (is_pointer<_Tp>::value
               || is_member_pointer<_Tp>::value)>
{ };

所以。据我所知，闭包类型既不是指针也不是成员指针。为了验证我什至写了一个小测试程序：

#include <functional>
#include <iostream>

int main(int argc, char* argv[])
{
  std::cout << "max stored locally size: " << sizeof(std::_Nocopy_types) << ", align: " << __alignof__(std::_Nocopy_types) << std::endl;

  auto lambda = [](){};

  typedef decltype(lambda) lambda_t;

  std::cout << "lambda size: " << sizeof(lambda_t) << std::endl;
  std::cout << "lambda align: " << __alignof__(lambda_t) << std::endl;

  std::cout << "stored locally: " << ((std::__is_location_invariant<lambda_t>::value
     && sizeof(lambda_t) <= std::_Function_base::_M_max_size
     && __alignof__(lambda_t) <= std::_Function_base::_M_max_align
     && (std::_Function_base::_M_max_align % __alignof__(lambda_t) == 0)) ? "true" : "false") << std::endl;
}

输出是：

max stored locally size: 16, align: 8
lambda size: 1
lambda align: 1
stored locally: false

所以，我的问题如下：用 lambda 初始化 std::function 是否总是导致堆分配？还是我错过了什么？

4

3 回答 3

7

从 GCC 4.8.1 开始，libstdc++ 中的 std::function 仅针对指向函数和方法的指针进行优化。因此，无论您的仿函数（包括 lambda）的大小如何，从中初始化一个 std::function 都会触发堆分配。不幸的是，也不支持自定义分配器。

Visual C++ 2012 和 LLVM libc++ 确实避免分配任何足够小的仿函数。

请注意，要让您的仿函数启动此优化，应该满足 std::is_nothrow_move_constructible。这是为了支持 noexcept std::function::swap()。幸运的是，如果所有捕获的值都满足，则 lambdas 满足此要求。

您可以编写一个简单的程序来检查各种编译器的行为：

#include <functional>
#include <iostream>

// noexpect missing in MSVC11
#ifdef _MSC_VER
# define NOEXCEPT
#else
# define NOEXCEPT noexcept
#endif

struct A
{
    A() { }
    A(const A&) { }
    A(A&& other) NOEXCEPT { std::cout << "A(A&&)\n"; }

    void operator()() const { std::cout << "A()\n"; }

    char data[FUNCTOR_SIZE];
};

int main()
{
    std::function<void ()> f((A()));
    f();

    // prints "A(A&&)" if small functor optimization employed
    auto f2 = std::move(f); 

    return 0;
}
于 2013-06-24T14:51:24.060 回答
2

我敢打赌，如果你添加了这个：

std::cout << "std::__is_location_invariant: " << std::__is_location_invariant<lambda_t>::value << std::endl;

你会回来：

std::__is_location_invariant: 0

至少ideone是这么说的。

于 2012-09-17T01:31:07.627 回答
1

std::function 的分配是一个实现细节；但是最后我检查了一下，msvc 的最大仿函数大小是 12 个字节，gcc 是 16 个字节，boost+msvc 是 24 个字节。

于 2012-09-17T01:05:37.737 回答