【问题标题】：Code runs 6 times slower with 2 threads than with 1使用 2 个线程的代码运行速度比使用 1 个线程慢 6 倍
【发布时间】：2013-06-25 06:06:11
【问题描述】：

原来的问题：

所以我写了一些代码来试验线程并做一些测试。

代码应该创建一些数字，然后找到这些数字的平均值。

我认为向您展示我目前所拥有的东西会更容易。我期望使用两个线程，代码的运行速度大约是原来的 2 倍。用秒表测量它，我认为它的运行速度慢了大约 6 倍！编辑：现在使用计算机和时钟（）函数来告诉时间。

void findmean(std::vector<double>*, std::size_t, std::size_t, double*);


int main(int argn, char** argv)
{

    // Program entry point
    std::cout << "Generating data..." << std::endl;

    // Create a vector containing many variables
    std::vector<double> data;
    for(uint32_t i = 1; i <= 1024 * 1024 * 128; i ++) data.push_back(i);

    // Calculate mean using 1 core
    double mean = 0;
    std::cout << "Calculating mean, 1 Thread..." << std::endl;
    findmean(&data, 0, data.size(), &mean);
    mean /= (double)data.size();

    // Print result
    std::cout << "  Mean=" << mean << std::endl;

    // Repeat, using two threads
    std::vector<std::thread> thread;
    std::vector<double> result;
    result.push_back(0.0);
    result.push_back(0.0);
    std::cout << "Calculating mean, 2 Threads..." << std::endl;

    // Run threads
    uint32_t halfsize = data.size() / 2;
    uint32_t A = 0;
    uint32_t B, C, D;
    // Split the data into two blocks
    if(data.size() % 2 == 0)
    {
        B = C = D = halfsize;
    }
    else if(data.size() % 2 == 1)
    {
        B = C = halfsize;
        D = hsz + 1;
    }

    // Run with two threads
    thread.push_back(std::thread(findmean, &data, A, B, &(result[0])));
    thread.push_back(std::thread(findmean, &data, C, D , &(result[1])));

    // Join threads
    thread[0].join();
    thread[1].join();

    // Calculate result
    mean = result[0] + result[1];
    mean /= (double)data.size();

    // Print result
    std::cout << "  Mean=" << mean << std::endl;

    // Return
    return EXIT_SUCCESS;
}


void findmean(std::vector<double>* datavec, std::size_t start, std::size_t length, double* result)
{
    for(uint32_t i = 0; i < length; i ++) {
        *result += (*datavec).at(start + i);
    }
}

我不认为这段代码很精彩，如果你能提出改进它的方法，我也将不胜感激。

注册变量：

一些人建议为函数“findmean”创建一个局部变量。这就是我所做的：

void findmean(std::vector<double>* datavec, std::size_t start, std::size_t length, double* result)
{
register double holding = *result;
for(uint32_t i = 0; i < length; i ++) {
    holding += (*datavec).at(start + i);
}
*result = holding;
}

我现在可以报告：代码运行的执行时间几乎与单线程相同。这是 6 倍的巨大改进，但肯定有办法让它快近两倍吗？

注册变量和 O2 优化：

我已将优化设置为“O2” - 我将创建一个包含结果的表格。

目前的结果：

没有优化或寄存器变量的原始代码： 1 个线程：4.98 秒，2 个线程：29.59 秒

添加了寄存器变量的代码： 1 线程：4.76 秒，2 线程：4.76 秒

使用 reg 变量和 -O2 优化： 1 个线程：0.43 秒，2 个线程：0.6 秒 2 个线程现在变慢了吗？

根据 Dameon 的建议，在两个结果变量之间放置一大块内存： 1 线程：0.42 秒，2 线程：0.64 秒

根据 TAS 的使用迭代器访问向量内容的建议： 1 线程：0.38 秒，2 线程：0.56 秒

Core i7 920（单通道内存 4GB）同上： 1 线程：0.31 秒，2 线程：0.56 秒

Core i7 920（双通道内存 2x2GB）同上： 1 线程：0.31 秒，2 线程：0.35 秒

【问题讨论】：

由于线程同时访问内存正好是 128 MiB 偏移量，这可能是错误共享。
听起来有点慢。在大约 1982 年的多处理器实验中，该应用在 2 个处理器上的运行速度仅比 1 个慢 30%。
@Damon，你能解释一下吗？您的意思是在 128MB 偏移处的总和之间存在重叠吗？什么是虚假分享？
@Edward Bird：这基本上意味着线程竞争相同的缓存行（这取决于关联性和缓存大小，这有点复杂......但我认为 Agner Fog 的网站上有一个综合公式，IIRC）。您可以尝试以不同的方式划分工作，例如以更小的（例如 128k 或 512k）块。如果这“神奇地”解决了性能问题，你就知道了。
@Damon 您能否向我解释一下为什么这可能会防止错误共享，因为 result[0] 和 result[1] 仍然是相邻的？

标签： c++ multithreading performance optimization

【解决方案1】：

为什么 2 个线程比 1 个线程慢 6 倍？

你被 false sharing 的坏情况打击了。

去掉虚假共享后，为什么2线程不比1线程快？

您的内存带宽已成为瓶颈。

虚假分享：

这里的问题是每个线程都在访问相邻内存位置的result 变量。它们很可能落在同一个缓存行上，因此每次线程访问它时，都会在内核之间反弹缓存行。

每个线程都在运行这个循环：

for(uint32_t i = 0; i < length; i ++) {
    *result += (*datavec).at(start + i);
}

您可以看到result 变量被非常频繁地访问（每次迭代）。因此，每次迭代，线程都在争夺同一个缓存行，该缓存行同时保存了result 的两个值。

通常，编译器应将*result 放入寄存器，从而删除对该内存位置的常量访问。但由于您从未启用优化，因此编译器很可能确实仍在访问内存位置，因此在循环的每次迭代中都会产生错误共享惩罚。

内存带宽：

一旦你消除了错误共享并摆脱了 6 倍的减速，你没有得到改进的原因是你已经用尽了内存带宽。

当然，您的处理器可能是 4 个内核，但它们都共享相同的内存带宽。您对数组求和的特定任务对每次内存访问几乎没有（计算）工作。单个线程已经足以最大化您的内存带宽。因此，使用更多线程不太可能给您带来太多改进。

简而言之，不，您无法通过向数组添加更多线程来显着加快对数组求和的速度。

【讨论】：

我应该创建两个独立的结果变量，而不是在一个向量内，否则这不会有帮助吗？
@EdwardBird 尝试声明一个局部变量来保存总和，并且只在循环结束时写入它。但我仍然不确定，因为编译器无论如何都应该将*result 保存在寄存器中。
@EdwardBird 快速提问，您启用优化了吗？
@Mystical，不，我没有开启优化。我在 Code::Blocks 上使用 g++-4.8，从 3 天前开始通宵构建。
@EdwardBird 没有优化 => 基准测试结果没用。

【解决方案2】：

如其他答案所述，您在结果变量上看到错误共享，但还有另一个位置发生这种情况。 std::vector<T>::at() 函数（以及std::vector<T>::operator[]()）在每个元素访问时访问向量的长度。为避免这种情况，您应该改用迭代器。此外，使用std::accumulate() 将允许您利用您正在使用的标准库实现中的优化。

以下是代码的相关部分：

thread.push_back(std::thread(findmean, std::begin(data)+A, std::begin(data)+B, &(result[0])));
thread.push_back(std::thread(findmean, std::begin(data)+B, std::end(data), &(result[1])));

和

void findmean(std::vector<double>::const_iterator start, std::vector<double>::const_iterator end, double* result)
{
    *result = std::accumulate(start, end, 0.0);
}

这始终为我的 32 位上网本上的两个线程提供更好的性能。

【讨论】：

阅读我的评论以回复您的评论。
仅在读取变量时实际上不会发生错误共享。那是因为缓存线只会被复制到核心上。只有当有写入会导致缓存线乒乓球。
我已经实现了迭代器的方案，程序稍微快一点。谢谢您的帮助。请参阅上面我的答案的结果部分。但是，您所说的使用累积是无稽之谈，因为这是一个测试用例，仅用于评估线程的性能，在大块内存上定期访问内存。这就是该计划旨在评估的内容。因此，我不在 for 循环中添加数字。我知道我可以这样做。
@Mysticial 为什么写作会导致问题？我的理解是可以异步完成写入，并且如果写入仍处于挂起状态，则当 cpu 需要再次访问该内存部分时，唯一的等待发生？那么显然我的理解不正确？
@EdwardBird 抱歉，在我发布解决方案之前没有看到您对我的评论的回答。以为我错过了。

【解决方案3】：

更多线程并不意味着更快！创建和上下文切换线程存在开销，即使运行此代码的硬件也会影响结果。对于这样一个微不足道的工作，最好是一个线程。

【讨论】：

【解决方案4】：

这可能是因为启动和等待两个线程的成本比在单个循环中计算结果要多得多。您的数据大小为 128MB，这对于现代处理器在单个循环中处理来说并不多。

【讨论】：

我原以为一个线程会花不到一秒钟的时间来启动，这不正确吗？
可能，但我认为整个程序应该不到一秒钟。此外，创建线程并等待它完成可能会导致上下文切换，这非常昂贵。
如果您有足够的 RAM，请尝试将数组大小设置为几个千兆字节。
好的，我将它增加到2GB并报告。
我试过了，但出现了同样的结果。由于 double 占用了 64bits 的内存空间，所以我只将向量中的项数增加了一倍，达到了 2GB 的内存分配。如果我再次加倍，计算机开始使用交换空间，然后它 laggggggssss