C++中向量的向量中索引的最有效排序

Most efficient ordering of indices in vector of vector in C++

本文关键字：向量 排序 有效 索引 C++      更新时间：2023-10-16

这主要是一个C++概念问题。如果我有一个矩阵（存储为向量的向量），我必须访问它，它在每个维度上的大小都非常不同。我有很多步骤，我在较大的维度上循环，并在较小的维度上执行操作。我想知道，从访问时间和矩阵操作的效率角度来看，以下两个例子中哪一个更有效：

组织1:

A=vector<vector<float>>(1000,vector<float>(10,0.0)); 
sumAcrossSmallerDimension=vector<float>(1000,0.0);
for(int i=0;i<1000;i++)
     for(int j=0;j<10;j++)
        sumAcrossSmallerDimension[i]+=A[i][j];

组织2:

A=vector<vector<float>>(10,vector<float>(1000,0.0)); 
sumAcrossSmallerDimension=vector<float>(1000,0.0);
for(int i=0;i<1000;i++)
     for(int j=0;j<10;j++)
        sumAcrossSmallerDimension[i]+=A[j][i];

在第二个例子中，似乎每个集合A条目都会更快地加载，但为了在j维度上求和，每次i迭代都要在内存中跳10次，以找到相应的j条目。

在第一个例子中，加载A似乎会更慢，但随后较低维度中的所有条目都很容易相加。

对此感到好奇，感谢您的帮助！

我认为线性地址空间而不是矢量的矢量将为您提供最佳的缓存位置：

#include <memory>
#include <algorithm>
#include <utility>
#include <vector>
#include <numeric>
struct vv
{
  vv(std::size_t rows, std::size_t columns, double init)
    : _rows(rows), _columns(columns), _size(_rows * _columns)
    , _pdata(std::make_unique<double[]>(_size))
    {
      std::fill(_pdata.get(), _pdata.get() + _size, init);
    }
  const double* operator[](std::size_t i) const {
    return std::addressof(_pdata.get()[i * _columns]);
  }
  double rowSum(std::size_t i) const {
    auto p = (*this)[i];
    return std::accumulate(p, p + _columns, 0.0, std::plus<>());
  }
  std::size_t _rows, _columns, _size;
  std::unique_ptr<double[]> _pdata;
};
int main()
{
  vv v(1000, 10, 10.0);
  auto sumAcrossSmallerDimension = std::vector<double>(1000,0.0);
  for(std::size_t i = 0 ; i < 1000 ; ++i)
  {
    sumAcrossSmallerDimension[i] += v.rowSum(i);
  }
}
相关文章：