Question

我已经设置了一个测试程序来比较数组访问性能和std :: vector的性能。我发现了几个类似的问题，但似乎都没有解决我的具体问题。一段时间以来，为什么数组访问速度似乎比矢量访问快6倍，当我在过去读过它们应该是等价的时候，我一直在挠头。事实证明，这似乎是英特尔编译器（v12）和优化（出现在-O1以上的任何东西）的函数，因为我看到使用gcc v4.1.2时std :: vector的性能更好，而数组有< em>仅 gcc v4.4.4的2倍优势。我正在使用Xeon X5355内核的RHEL 5.8机器上运行测试。顺便说一句，我发现迭代器比元素访问更快。

我正在使用以下命令进行编译：

icpc -fast test.cc
g++44 -O3 test.cc

有人能解释速度的显着提高吗？

#include <vector>
#include <iostream>

using namespace std;

int main() {
  int sz = 100;
  clock_t start,stop;
  int ncycle=1000;
  float temp  = 1.1;

  // Set up and initialize vector
  vector< vector< vector<float> > > A(sz, vector< vector<float> >(sz,  vector<float>(sz, 1.0)));

  // Set up and initialize array
  float*** a = new float**[sz];
  for( int i=0; i<sz; ++i) {
    a[i] = new float*[sz];
    for( int j=0; j<sz; ++j) {
      a[i][j] = new float[sz]();
      for( int k=0; k<sz; ++k)
        a[i][j][k] = 1.0;
    }
  }

  // Time the array
  start = clock();
  for( int n=0; n<ncycle; ++n )
    for( int i=0; i<sz; ++i )
      for( int j=0; j<sz; ++j )
        for( int k=0; k<sz; ++k )
          a[i][j][k] *= temp;

  stop = clock();
  std::cout << "STD ARRAY: " << double((stop - start)) / CLOCKS_PER_SEC << " seconds"     << std::endl;

  // Time the vector
      start = clock();
  /*
  */
  for( int n=0; n < ncycle; ++n )
    for (vector<vector<vector<float> > >::iterator it1 = A.begin(); it1 != A.end();     ++it1)
      for (vector<vector<float> >::iterator it2 = it1->begin(); it2 != it1->end();     ++it2)
        for (vector<float>::iterator it3 =it2->begin(); it3 != it2->end(); ++it3)
          *it3 *= temp;
  /*
     for( int n=0; n < ncycle; ++n )
       for( int i=0; i < sz; ++i )
         for( int j=0; j < sz; ++j )
           for( int k=0; k < sz; ++k )
             A[i][j][k] *= temp;
  */

  stop = clock();
  std::cout << "VECTOR: " << double((stop - start)) / CLOCKS_PER_SEC << " seconds" <<     std::endl;


  for( int i=0; i<100; ++i) {
    for( int j=0; j<100; ++j)
      delete[] a[i][j];
  }
  for( int i=0; i<100; ++i) {
    delete[] a[i];
  }
  delete[] a;
  return 0;
}

解决

在注意到Bo指示编译器“知道关于循环的所有内容”并且因此可以比向量情况更优化它之后，我通过调用“rand（）”将乘法替换为“temp”乘法。这平整了比赛场地，实际上似乎给了std :: vector一点点领先。各种情况的时间安排如下：

ARRAY (flat): 111.15 seconds
ARRAY (flat): 0.011115 seconds per cycle
ARRAY (3d): 111.73 seconds
ARRAY (3d): 0.011173 seconds per cycle
VECTOR (flat): 110.51 seconds
VECTOR (flat): 0.011051 seconds per cycle
VECTOR (3d): 118.05 seconds
VECTOR (3d): 0.011805 seconds per cycle
VECTOR (flat iterator): 108.55 seconds
VECTOR (flat iterator): 0.010855 seconds per cycle
VECTOR (3d iterator): 111.93 seconds
VECTOR (3d iterator): 0.011193 seconds per cycle

外卖似乎是矢量和数组一样快，并且在展平（连续内存）并与迭代器一起使用时稍快一些。我的实验仅平均超过10,000次迭代，因此可以认为这些都大致相同，并且选择使用哪个应该由最容易使用的选择来确定;就我而言，这将是“3d迭代器”案例。

Answer 1

这里没有黑魔法，编译器很容易看到这里

for( int n=0; n<ncycle; ++n )
   for( int i=0; i<sz; ++i )
     for( int j=0; j<sz; ++j )
       for( int k=0; k<sz; ++k )
          a[i][j][k] *= temp;

在编译时一切都是已知的。它可以轻松展开循环以加快速度。

Answer 2

数组只是指向内存区域的指针。你不可能比这更直接。

向量需要调用内联函数来执行相同的操作。这可能与否真正内联。 asline和__forceinline只是编译器内联代码的指南。反过来，编译器可以自由地做任何想做的事情。

此外，迭代器不一定是指针。编译器调用内联函数，可以或不内联。（再次内联是对编译器的指导，而不是规则）。

如有疑问。编译到程序集并查看生成的代码。如果编译器正在执行其工作，则应该没有明显的区别。但是，如果编译器没有内联应该内联的内容，那么使用向量而不是数组会得到一个巨大的性能损失编译器。

Answer 3

嵌套数组中的所有元素都位于连续的内存位置，因此当编译器遇到a[x][y][z]形式的表达式时，它会生成计算实际索引的代码，该代码只涉及整数乘法和加法。另一方面，嵌套的std::vector实际上是嵌套的。表达式v[x][y][z]涉及两个更多级别的间接，因为在v[x]处确实有一个std::vector对象，其中包含一个指向矢量数组的指针，这些矢量又包含实际数据。 / p>

内部数组访问比std :: vector访问快得多 - Black Magic？

3 个答案: