将大向量分块为较小的向量，而无需额外的堆分配

Chunking a big vector to smaller ones without extra heap allocation

本文关键字：向量 分配      更新时间：2023-10-16

我需要将 3 个 std：：vector 实例的 3 个堆分配替换为 只有一个连续的堆分配，然后在这 3 个向量之间共享它。这些矢量大小不会改变，因此在向它们推送或插入元素时，我无需担心分配新的连续存储。我的实验结果表明，当我将这 3 个大小为 n 的向量替换为一个大小为 *3*n* 的向量时，对于不同的大小，我的速度提高了 2 倍。

但是，我不知道如何在不进行任何额外堆分配的情况下完成从大向量中制作较小向量的工作。

std::array<std::vector<double>, 3>
chunck_vector(size_t size)
{
std::vector<double> * underlying_vec = new std::vector<double>(3*size, 1.0);
// how to avoid extra heap allocations in constructor of small vectors
std::vector<double> vec0(underlying_vec->begin()         , underlying_vec->begin() + size);
std::vector<double> vec1(underlying_vec->begin() + size  , underlying_vec->begin() + 2*size);
std::vector<double> vec2(underlying_vec->begin() + 2*size, underlying_vec->end());
return {vec0, vec1, vec2};
}
int main(int argc, char const *argv[])
{
int size = 1000;
auto&& chunked_vecs = chunck_vector(size);
// passing each chunk to different functions
// each chunk should be responsible for managing its resources
foo0(std::get<0>(chunked_vecs));
foo1(std::get<1>(chunked_vecs));
foo2(std::get<2>(chunked_vecs));
return 0;
}

我尝试编写自己的向量类，它的构造函数接受两个迭代器，指定属于该向量的underlying_vec存储部分的开始和结束，但是当涉及到释放资源的工作时，它听起来不是一个干净的解决方案当底层向量不再可访问并解决内存泄漏问题时。

显然，使用在这三个向量之间共享的自定义分配器并分配一次连续内存并将其分配给相应的向量似乎是一个更好的解决方案，但是由于我从未写过一个，任何提示或建议帮助我开始编码将不胜感激。

这就是 gsl：：span 的设计目的。

你可以在这里找到一个实现。建议将其纳入C++标准库。

你可以像这样使用它：

void double_data(gsl::span<int> sp)
{
for(auto& i: sp)
i *= 2;
}
void tripple_data(gsl::span<int> sp)
{
for(auto& i: sp)
i *= 3;
}
int main()
{
std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto sp = gsl::make_span(v); // the whole vector
auto sp1 = sp.subspan(0, 5); // first 5 elements
auto sp2 = sp.subspan(5, 5); // last five elements
double_data(sp1); // process it like you would a container
tripple_data(sp2);
for(auto i: v)
std::cout << i << ' ';
std::cout << 'n';
}

输出：

2 4 6 8 10 18 21 24 27 30

您可以使用std::shared_ptr，其主要目的是管理共享资源。首先，创建缓冲区：

std::shared_ptr<double> underlying(new double[3 * size], std::default_delete<double[]>());

在这里，您必须使用default_delete作为显式删除程序，以便使用正确的operator delete[]进行释放。顺便说一句，我听说在 C++17 中，如果您使用shared_ptr<double[]>，您不再需要使用显式删除器.

然后使用别名构造函数定义较小的容器：

std::shared_ptr<double> vec0(underlying, underlying.get());
std::shared_ptr<double> vec1(underlying, underlying.get() + size);
std::shared_ptr<double> vec2(underlying, underlying.get() + 2 * size);

在这里，您可以使用"向量"，直到最后一个向量超出范围，当发生这种情况时，缓冲区将被解除分配。然而，这些不是向量——例如，它们不存储它们的大小，只存储指向第一个元素的指针。

相关文章：