std::vector 如何比普通数组快？

Question

我在对循环缓冲区进行基准测试时偶然发现了这一点。谁能解释一下 std::vector 在这种情况下如何胜过普通数组？

#include <iostream>
#include <vector>

struct uint_pair {
    unsigned int a, b;
    uint_pair (unsigned int x = 0, unsigned int y = 0) : a(x), b(y) {}
};

struct container {
    unsigned int pos;

#ifdef USE_VECTOR
    std::vector<uint_pair> data;
    container() : pos(0) { data.resize(16); }
#else
    uint_pair data[16];
    container() : pos(0) {}
#endif

    void add(uint_pair val) {
        data[++pos % 16] = val;
    }
};

int main() {
    container c;
    for (unsigned int i = 0; i < 1000000000; i++) c.add(uint_pair{i, i});
    std::cout << c.data[0].a << " " << c.data[0].b << std::endl;
}

这些是我使用 GCC 得到的结果（与 Clang 类似）：

g++ -o bench -std=c++0x -Os main.cpp -D'USE_VECTOR'
real    0m8.757s
user    0m8.750s
sys     0m0.002s

g++ -o bench -std=c++0x -Os main.cpp
real    0m9.215s
user    0m9.209s
sys     0m0.002s

Answer 1

以下是消除差异的方法。而不是你的add，使用这样的函数：

void set(unsigned int x, unsigned int y) {
    ++pos;
    data[pos % 16].a = x;
    data[pos % 16].b = y;
}

这样称呼：

for (unsigned int i = 0; i < 1000000000; i++) c.set(i, i);

这与您的完全相同，但它避免了语义上创建临时对象。看起来当您使用向量时，编译器能够更好地优化临时变量。

$ g++-4.8 -o bench -std=c++11 -Os main.cpp -DUSE_VECTOR
$ time ./bench 
999999999 999999999

real    0m0.635s
user    0m0.630s
sys 0m0.002s

$ g++-4.8 -o bench -std=c++11 -Os main.cpp
$ time ./bench 
999999999 999999999

real    0m0.644s
user    0m0.639s
sys 0m0.002s

在我的机器上，set 和 add 方法在使用向量时产生相同的性能。只有数组显示了差异。为了进一步证明优化，如果您使用 -O0 进行编译，那么数组方法会稍微快一些（但都比使用 -Os 慢 10 倍以上）。

这并没有解释为什么编译器会以不同的方式处理这两者。毕竟，向量是由数组支持的。此外，std::array 的行为与您的 C 样式数组相同。

Answer 2

一个问题是“pos”成员在你的结构中的位置。

对于 c 数组，请记住它连续存储在与您的“pos”成员相邻的内存中。当数据被推入 c 数组时，必须发出额外的指令来偏移到结构中超过“pos”成员的位置。但是，写入向量没有这样的限制，因为它的内存位于其他地方。

要获得更多性能，请确保最热门的数据位于缓存行的前面。

编辑：

为了让 c 数组的执行速度与向量一样快，c 数组必须在 64 位机器上分配在 8 字节边界上。所以像：

uint_pair* data;
unsigned int pos;

container() : pos(0) {
    std::size_t bufSize = sizeof(uint_pair) * 17;
    void* p = new char[bufSize];
    p = std::align(8, sizeof(uint_pair), p, bufSize);
    data = reinterpret_cast<uint_pair*>(p);
}

稍加修改的添加功能：

void add(unsigned int x, unsigned int y) {
    auto& ref = data[pos++ % 16];
    ref.a = x;
    ref.b = y;
}

现在的 c 数组：

real    0m0.735s
user    0m0.730s
sys     0m0.002s

还有 std::vector:

real    0m0.743s
user    0m0.736s
sys     0m0.004s

标准库的实现者正在为你竭尽全力:)

Answer 3

由于 operator=(rvalue reference)，C++11 编译器似乎为向量生成了更好的代码。 首先，在 C++03 编译器中，普通数组比向量快两倍。 其次，如果您使用 Adam 建议的 void set(unsigned int x, unsigned int y)，则没有区别。

向量的汇编代码

.L49:
leal    (%rdi,%rax), %esi
andl    $15, %esi
leaq    (%rdx,%rsi,8), %rsi
movl    %eax, (%rsi)
movl    %eax, 4(%rsi)
incq    %rax
cmpq    $1000000000, %rax
jne .L49

对于普通数组

.L3:
movl    12(%rsp), %edx
incl    %edx
movl    %edx, 12(%rsp)
andl    $15, %edx
leaq    12(%rsp,%rdx,8), %rdx
movl    %eax, 4(%rdx)
movl    %eax, 8(%rdx)
incl    %eax
cmpl    $1000000000, %eax
jne .L3