Initializing vector in multithread - c++

Question

I have a large vector std::vector<some_class> some_vector which I need to initialize with different values of constructors some_class(constructor_parameters). The normal way to do it would be something like:
std::vector<some_class> some_vector
some_vector.reserve(length)
for (...) some_vector.push_back(some_class(constructor_parameters))
But because this vector is large, I want to do this in parallel. Is there any way to split the vector and push_back at q different position of the vector so each thread can start initializing a different part of the vector?
I read some answers with splitting / joining vector and haven`t found anything useful. As my vector is really large I have to avoid something like creating new vector for each thread and then copying them into the original one - I can use only one big chunk of memory.
I tried to use some_vector.at(some_loc) = some_class(constructor_parameters) but this isn`t working with uninitialized vector.
I can initialize vector to some dump values and then use at to initiaize it to proper values, but it is not efficient.
So my question - how to efficiently (in terms of memory consumption and computing time) initialize a large vector?
EDIT: to answer comments:
Size - the container doesn`t change its size during the run of program, but the size is not known at compiling time. The size is huge because that's just the scope of the problem - I'm performing cosmological N-body simulation where number of particles / mesh cells can be easily 1024^3 and more.
Ctors - now they are just assigning values to class member (3 ~ 7 assignments) but I was planning to add some computation
Members - are easily coppyable, typically 2 std::vector(3)
Why vectors - I was originally using only basic type arrays and new / delete directive. I wanted to use vector because of their various functionalities, automatic memory (de)allocating, easier loop using iterators, etc. I just assumed that they should be easy to implement into multi thread with all their other good properties...

Answer 1

For general types T, the problem with what you describe is that it takes a fair amount of state to track which of the T have been constructed, and which have not.
If you compress the "is this a valid value" data into a bitfield, checking for validity is a very cache incoherent.
One easy approach is a vector<optional<T>> in C++17 or with boost. Pre-size (to nullopt), then use emplace to construct the terms in whatever thread you want.
Finally, consider not using a single vector. Write a wrapper that splices multiple vectors together into one visible container.

Answer 2

There are two solutions I can think of.
One is to use a concurrent data structure, such as TBB's concurrent_vector. See its documents
The second is to write a custom allocator, whose construct member does not invoke the default constructor when called without arguments. And then allocate the vector once, and initialize each element in parallel. Care need to be taken to ensure that such a construct will not cause you troubles later. It will work best if you can use C++11 move semantics when you construct the new elements. In this case, the only thing you need to do in the master thread would be allocating the memory, a cost you can hardly avoid any way.
Here is a concrete example,
template <std::size_t n, std::size_t m>
class StirlingMatrix2
{
public:
StirlingMatrix2()
{
// compute the matrix of Stirling numbers
// relatively expensive
}
double operator()(std::size_t i, std::size_t j) const
{
return data_[i * (m + 1) + j];
}
private:
double data_[(n + 1) * (m + 1)];
}; // class StirlingMatrix
template <typename T, bool InvokeConstructor = true>
class Allocator
{
public:
// other member functions and types
template <typename U>
void construct(U *ptr)
{
construct_dispatch(
ptr, std::integral_constant<bool, InvokeConstructor>());
}
template <typename U, typename Arg, typename... Args>
void constrct(U *ptr, Arg &&arg, Args &&... args)
{
std::allocator<T>::construct(
ptr, std::forward<Arg>(arg), std::forward<Args>(args)...);
}
private:
template <typename U>
void construct_dispatch(U *ptr, std::true_type)
{
std::allocator<T>::construct(ptr);
}
template <typename U>
void construct_dispatch(U *, std::false_type)
{
}
}; // class Allocator
// specialization for void type is needed
int main()
{
constexpr n = 100;
constexpr m = 100;
using T = StirlingMatrix2<n, m>;
// each element will be constructed, very expensive
std::vector<T> svec1(N);
// allocate memory only
std::vector<T, Allocator<T, false>> svec2(N);
// within each thread
// invoke inplace new to construct elements
}
For this to work, there cannot be pointer members, or class members that is not trivial. Otherwise there's no way to be exception safe. Similar technique can be used if you don't have to use a container class and instead is conformable with manually manage memory through malloc, etc.