缓存友好std::list vs std::vector

随着CPU缓存变得越来越好，std::vector通常优于std::list，即使在测试std::list的强度时也是如此。出于这个原因，即使在我需要在容器中间删除/插入的情况下，我通常选择std::vector，但我意识到我从未测试过这一点，以确保假设是正确的。所以我设置了一些测试代码:

#include <iostream>
#include <chrono>
#include <list>
#include <vector>
#include <random>
void TraversedDeletion()
{
    std::random_device dv;
    std::mt19937 mt{ dv() };
    std::uniform_int_distribution<> dis(0, 100000000);
    std::vector<int> vec;
    for (int i = 0; i < 100000; ++i)
    {
        vec.emplace_back(dis(mt));
    }
    std::list<int> lis;
    for (int i = 0; i < 100000; ++i)
    {
        lis.emplace_back(dis(mt));
    }
    {
        std::cout << "Traversed deletion...n";
        std::cout << "Starting vector measurement...n";
        auto now = std::chrono::system_clock::now();
        auto index = vec.size() / 2;
        auto itr = vec.begin() + index;
        for (int i = 0; i < 10000; ++i)
        {
            itr = vec.erase(itr);
        }
        std::cout << "Took " << std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now() - now).count() << " μsn";
    }
    {
        std::cout << "Starting list measurement...n";
        auto now = std::chrono::system_clock::now();
        auto index = lis.size() / 2;
        auto itr = lis.begin();
        std::advance(itr, index);
        for (int i = 0; i < 10000; ++i)
        {
            auto it = itr;
            std::advance(itr, 1);
            lis.erase(it);
        }
        std::cout << "Took " << std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now() - now).count() << " μsn";
    }
}
void RandomAccessDeletion()
{
    std::random_device dv;
    std::mt19937 mt{ dv() };
    std::uniform_int_distribution<> dis(0, 100000000);
    std::vector<int> vec;
    for (int i = 0; i < 100000; ++i)
    {
        vec.emplace_back(dis(mt));
    }
    std::list<int> lis;
    for (int i = 0; i < 100000; ++i)
    {
        lis.emplace_back(dis(mt));
    }
    std::cout << "Random access deletion...n";
    std::cout << "Starting vector measurement...n";
    std::uniform_int_distribution<> vect_dist(0, vec.size() - 10000);
    auto now = std::chrono::system_clock::now();
    for (int i = 0; i < 10000; ++i)
    {
        auto rand_index = vect_dist(mt);
        auto itr = vec.begin();
        std::advance(itr, rand_index);
        vec.erase(itr);
    }
    std::cout << "Took " << std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now() - now).count() << " μsn";
    std::cout << "Starting list measurement...n";
    now = std::chrono::system_clock::now();
    for (int i = 0; i < 10000; ++i)
    {
        auto rand_index = vect_dist(mt);
        auto itr = lis.begin();
        std::advance(itr, rand_index);
        lis.erase(itr);
    }
    std::cout << "Took " << std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now() - now).count() << " μsn";
}
int main()
{
    RandomAccessDeletion();
    TraversedDeletion();
    std::cin.get();
}

所有结果用/02 (Maximize speed)编译。

第一个，RandomAccessDeletion()，生成一个随机索引并擦除该索引10,000次。我的假设是正确的，向量确实比列表快得多:

随机存取删除…

开始矢量测量…

耗时240299 μs

起始列表测量…

耗时1368205 μs

vector 比list 快5.6倍。我们很可能要感谢我们的缓存霸主带来的性能优势，尽管我们需要在每次删除时移动vector中的元素，但它的影响小于我们在基准测试中看到的列表查找时间。

所以我添加了另一个测试，在TraversedDeletion()中看到。它不使用随机位置进行删除，而是在容器中间选择一个索引，并将其作为基迭代器，然后遍历容器，擦除10,000次。

我的假设是，列表的性能只会略优于向量，或者与向量一样快。

相同执行的结果:

遍历删除…

起始向量测量....

占用195477 μs

起始列表测量…

耗时581 μs

哇。列表大约快336倍这与我的期望相差甚远。因此，在列表中有一些缓存未命中似乎并不重要，因为减少列表的查找时间更重要。

所以当涉及到角落/不寻常情况的性能时，这个列表显然仍然有一个非常强大的位置，或者我的测试用例在某些方面有缺陷?

这是否意味着列表现在只是在遍历容器中间进行大量插入/删除操作的合理选择，或者还有其他情况?

是否有一种方法可以改变向量访问&在TraversedDeletion()中删除，使它至少比列表更具竞争力?

回应@BoPersson的评论:

vec.erase(it, it+10000)将比执行10000要好得多单独的删除。

改变:

for (int i = 0; i < 10000; ++i)
{
    itr = vec.erase(itr);
}

:

vec.erase(itr, itr + 10000);

给我:

开始矢量测量…

耗时19 μs

这已经是一个重大的改进。