由于标准容器中元素的默认初始化而导致性能下降
Performance degradation due to default initialisation of elements in standard containers
(是的，我知道有一个几乎相同标题的问题，但答案并不令人满意，见下文)
编辑对不起，原来的问题没有使用编译器优化。这个问题现在已经解决了，但是为了避免琐碎的优化并更接近我的实际用例，测试被分成了两个编译单元。 当涉及到性能关键型应用程序时， ，当构建 然而，正如我的评论所指出的那样， 我得到以下计时(使用gcc 4.8与-O3;Clang 3.2产生了~慢10%的代码) 如果可以省略元素的默认构造，实际可能的加速可以通过以下作弊版本 当我们得到std::vector<>的构造函数具有线性复杂性的事实是一个麻烦。考虑下面这个简单的代码// compilation unit 1:
void set_v0(type*x, size_t n)
{
for(size_t i=0; i<n; ++i)
x[i] = simple_function(i);
}
// compilation unit 2:
std::vector<type> x(n); // default initialisation is wasteful
set_v0(x.data(),n); // over-writes initial values
x浪费了大量时间时。正如这个问题所探讨的那样，解决这个问题的传统方法似乎只是保留存储并使用push_back()填充数据:// compilation unit 1:
void set_v1(std::vector<type>&x, size_t n)
{
x.reserve(n);
for(size_t i=0; i<n; ++i)
x.push_back(simple_function(i));
}
// compilation unit 2:
std::vector<type> x(); x.reserve(n); // no initialisation
set_v1(x,n); // using push_back()
push_back()本身很慢，对于足够简单的可构造对象，例如 size_ts，当用于simple_function = [](size_t i) { return i; };
timing vector::vector(n) + set_v0();
n=10000 time: 3.9e-05 sec
n=100000 time: 0.00037 sec
n=1000000 time: 0.003678 sec
n=10000000 time: 0.03565 sec
n=100000000 time: 0.373275 sec
timing vector::vector() + vector::reserve(n) + set_v1();
n=10000 time: 1.9e-05 sec
n=100000 time: 0.00018 sec
n=1000000 time: 0.00177 sec
n=10000000 time: 0.020829 sec
n=100000000 time: 0.435393 sec
// compilation unit 2
std::vector<type> x; x.reserve(n); // no initialisation
set_v0(x,n); // error: write beyond end of vector
// note: vector::size() == 0
那么，我的第一个问题:是否有任何合法的方法来使用标准库容器来提供这些时间?还是我必须自己管理内存?
timing vector::vector + vector::reserve(n) + set_v0(); (CHEATING)
n=10000 time: 8e-06 sec
n=100000 time: 7.2e-05 sec
n=1000000 time: 0.000776 sec
n=10000000 time: 0.01119 sec
n=100000000 time: 0.298024 sec
现在，我真正想要的是使用多线程来填充容器。原始代码(为了简单起见，在本例中使用openMP，暂时不包括clang)
// compilation unit 1
void set_v0(type*x, size_t n)
{
#pragma omp for // only difference to set_v0() from above
for(size_t i=0; i<n; ++i)
x[i] = simple_function(i);
}
// compilation unit 2:
std::vector<type> x(n); // default initialisation not mutli-threaded
#pragma omp parallel
set_v0(x,n); // over-writes initial values in parallel
现在的问题是，所有元素的默认初始化都不是多线程的，这会导致潜在的严重性能下降。下面是set_omp_v0()的时间和一个等效的作弊方法(使用我macbook的intel i7芯片，4核，8超线程):
timing std::vector::vector(n) + omp parallel set_v0()
n=10000 time: 0.000389 sec
n=100000 time: 0.000226 sec
n=1000000 time: 0.001406 sec
n=10000000 time: 0.019833 sec
n=100000000 time: 0.35531 sec
timing vector::vector + vector::reserve(n) + omp parallel set_v0(); (CHEATING)
n=10000 time: 0.000222 sec
n=100000 time: 0.000243 sec
n=1000000 time: 0.000793 sec
n=10000000 time: 0.008952 sec
n=100000000 time: 0.089619 sec
请注意，作弊版本比串行作弊版本快3.3倍，大致与预期一致，但标准版本不是。
那么，我的第二个问题:是否有任何合法的方法来使用标准库容器，从而在多线程情况下提供这些时间? p。我发现了这个问题，其中std::vector通过提供uninitialized_allocator来避免默认初始化。这不再符合标准，但在我的测试用例中工作得非常好(参见下面我自己的答案和这个问题的详细信息)。
使用g++ 4.5，我能够实现从v0 (1.0s到0.8s)减少大约20%的运行时间，并且通过使用生成器直接构造v1从0.95s到0.8s稍微减少:
struct Generator : public std::iterator<std::forward_iterator_tag, int>
{
explicit Generator(int start) : value_(start) { }
void operator++() { ++value_; }
int operator*() const { return value_; }
bool operator!=(Generator other) const { return value_ != other.value_; }
int value_;
};
int main()
{
const int n = 100000000;
std::vector<int> v(Generator(0), Generator(n));
return 0;
}
好了，这是我问这个问题后学到的。
Q1 (是否有任何合法的方法来使用标准库容器来提供这些后一种计时?) 在某种程度上是，正如Mark和Evgeny的答案所示。为std::vector的构造函数提供生成器的方法省略了默认构造。
Q2 (是否有合法的方法使用标准库容器在多线程情况下提供这些后一种计时?) 没有，我认为没有。原因是在构造时，任何符合标准的容器都必须初始化其元素，以确保对元素析构函数的调用(在销毁或调整容器大小时)是格式良好的。由于std标准库容器在构造其元素时不支持使用多线程，因此这里不能复制Q1的技巧，因此不能省略默认构造。因此，如果我们想使用c++进行高性能计算，当涉及到管理大量数据时，我们的选择是有限的。我们可以
1声明一个容器对象，并在同一编译单元中立即(并发地)填充它，当编译器希望在构造时优化初始化时;
2诉诸new[]和delete[]，甚至malloc()和free()，当所有的内存管理和元素的构造都是我们的责任，而我们对c++标准库的潜在使用非常有限时。
3欺骗std::vector不使用省略默认构造的自定义 unitialised_allocator 初始化其元素。按照Jared Hoberock的想法，这样的分配器可能是这样的(参见这里):
// based on a design by Jared Hoberock
// edited (Walter) 10-May-2013, 23-Apr-2014
template<typename T, typename base_allocator = std::allocator<T> >
struct uninitialised_allocator
: base_allocator
{
static_assert(std::is_same<T,typename base_allocator::value_type>::value,
"allocator::value_type mismatch");
template<typename U>
using base_t =
typename std::allocator_traits<base_allocator>::template rebind_alloc<U>;
// rebind to base_t<U> for all U!=T: we won't leave other types uninitialised!
template<typename U>
struct rebind
{
typedef typename
std::conditional<std::is_same<T,U>::value,
uninitialised_allocator, base_t<U> >::type other;
}
// elide trivial default construction of objects of type T only
template<typename U>
typename std::enable_if<std::is_same<T,U>::value &&
std::is_trivially_default_constructible<U>::value>::type
construct(U*) {}
// elide trivial default destruction of objects of type T only
template<typename U>
typename std::enable_if<std::is_same<T,U>::value &&
std::is_trivially_destructible<U>::value>::type
destroy(U*) {}
// forward everything else to the base
using base_allocator::construct;
using base_allocator::destroy;
};
那么unitialised_vector<>模板可以这样定义:
template<typename T, typename base_allocator = std::allocator<T>>
using uninitialised_vector = std::vector<T,uninitialised_allocator<T,base_allocator>>;
，我们仍然可以使用几乎所有标准库的功能。尽管必须说uninitialised_allocator，以及由此暗示的unitialised_vector是不符合标准的，因为它的元素不是默认构造的(例如，vector<int>在构造之后不会有所有的0)。
当使用这个工具解决我的小测试问题时，我得到了很好的结果:
timing vector::vector(n) + set_v0();
n=10000 time: 3.7e-05 sec
n=100000 time: 0.000334 sec
n=1000000 time: 0.002926 sec
n=10000000 time: 0.028649 sec
n=100000000 time: 0.293433 sec
timing vector::vector() + vector::reserve() + set_v1();
n=10000 time: 2e-05 sec
n=100000 time: 0.000178 sec
n=1000000 time: 0.001781 sec
n=10000000 time: 0.020922 sec
n=100000000 time: 0.428243 sec
timing vector::vector() + vector::reserve() + set_v0();
n=10000 time: 9e-06 sec
n=100000 time: 7.3e-05 sec
n=1000000 time: 0.000821 sec
n=10000000 time: 0.011685 sec
n=100000000 time: 0.291055 sec
timing vector::vector(n) + omp parllel set_v0();
n=10000 time: 0.00044 sec
n=100000 time: 0.000183 sec
n=1000000 time: 0.000793 sec
n=10000000 time: 0.00892 sec
n=100000000 time: 0.088051 sec
timing vector::vector() + vector::reserve() + omp parallel set_v0();
n=10000 time: 0.000192 sec
n=100000 time: 0.000202 sec
n=1000000 time: 0.00067 sec
n=10000000 time: 0.008596 sec
n=100000000 time: 0.088045 sec
，当作弊版本和"合法"版本之间不再有区别时。
boost::transformed
对于单线程版本，可以使用boost::transformed。它有:
返回范围类别:rng的范围类别。
这意味着，如果你把Random Access Range给boost::transformed，它会返回Random Access Range，这将允许vector的构造函数预先分配所需的内存量。
你可以这样使用:
const auto &gen = irange(0,1<<10) | transformed([](int x)
{
return exp(Value{x});
});
vector<Value> v(begin(gen),end(gen));
现场演示
#define BOOST_RESULT_OF_USE_DECLTYPE
#include <boost/range/adaptor/transformed.hpp>
#include <boost/container/vector.hpp>
#include <boost/range/irange.hpp>
#include <boost/progress.hpp>
#include <boost/range.hpp>
#include <iterator>
#include <iostream>
#include <ostream>
#include <string>
#include <vector>
#include <array>
using namespace std;
using namespace boost;
using namespace adaptors;
#define let const auto&
template<typename T>
void dazzle_optimizer(T &t)
{
auto volatile dummy = &t; (void)dummy;
}
// _______________________________________ //
using Value = array<int,1 << 16>;
using Vector = container::vector<Value>;
let transformer = [](int x)
{
return Value{{x}};
};
let indicies = irange(0,1<<10);
// _______________________________________ //
void random_access()
{
let gen = indicies | transformed(transformer);
Vector v(boost::begin(gen), boost::end(gen));
dazzle_optimizer(v);
}
template<bool reserve>
void single_pass()
{
Vector v;
if(reserve)
v.reserve(size(indicies));
for(let i : indicies)
v.push_back(transformer(i));
dazzle_optimizer(v);
}
void cheating()
{
Vector v;
v.reserve(size(indicies));
for(let i : indicies)
v[i]=transformer(i);
dazzle_optimizer(v);
}
// _______________________________________ //
int main()
{
struct
{
const char *name;
void (*fun)();
} const tests [] =
{
{"single_pass, no reserve",&single_pass<false>},
{"single_pass, reserve",&single_pass<true>},
{"cheating reserve",&cheating},
{"random_access",&random_access}
};
for(let i : irange(0,3))
for(let test : tests)
progress_timer(), // LWS does not support auto_cpu_timer
(void)i,
test.fun(),
cout << test.name << endl;
}
我实际上要建议在这种情况下滚动您自己的容器或寻找替代品，因为我看到它的方式，您的固有问题不是标准容器默认构造元素。对于一个容量可以在建造时确定的容器，它试图使用可变容量的容器。
不存在标准库不必要地默认构造元素的实例。vector只对它的填充构造函数和resize这样做，这两个构造函数在概念上都是通用容器所必需的，因为它们的目的是调整容器的大小以包含有效的元素。同时，这样做很简单:
T* mem = static_cast<T*>(malloc(num * sizeof(T)));
for (int j=0; j < num; ++j)
new (mem + j) T(...); // meaningfully construct T
...
for (int j=0; j < num; ++j)
mem[j].~T(); // destroy T
free(mem);
…然后用上面的代码构建一个异常安全的符合raii的容器。这就是我在您的情况下的建议，因为如果默认构造在填充构造函数上下文中浪费得足以不可忽略，以至于替代reserve和push_back或emplace_back同样不充分，那么即使容器将其容量和大小视为变量也是不可忽略的开销，此时您更有理由寻找其他东西，包括从上面的概念滚动您自己的东西。
标准库的效率非常高，在苹果与苹果的比较中很难进行匹配，但在这种情况下，您的需求需要橙子而不是苹果。在这种情况下，直接拿一个橙子比试着把苹果变成橙子更容易。
- 初始化具有非默认构造函数的std::数组项的更好方法
- 有没有一种代码密度较低的方法来使用非默认构造函数初始化数组?
- 副本初始化的默认模板参数推导
- 使用 std::分配器在 constexpr 中进行默认初始化
- 在C++中使用默认构造函数初始化对象的不同方法
- 强制使用默认构造函数对成员进行未初始化的声明
- 使用默认构造函数初始化对象的不同方法
- 在没有默认构造函数时使用垃圾数据初始化对象
- 为什么对象默认初始化，但基元不在C++？
- 默认参数和空列表初始化
- 为什么std::atomic的默认构造函数不默认初始化底层存储值
- C++中未初始化成员布尔变量的默认值是多少?
- 两个成员，在Base中默认初始化，可能在Derived中非默认初始化
- 默认初始化无法正常工作
- 如何用默认值0或-1初始化unordered_set
- C++11 默认类成员初始化与初始值设定项列表同时
- 使用聚合初始化模拟默认函数参数是否存在任何陷阱?
- 初始化在类类型 #define 中定义的非静态成员数组，不带默认 ctor
- 在皮条类中初始化默认值的最佳位置
- 值初始化:默认初始化或零初始化
