在C+中，数组的并行求和比顺序求和慢+； 我用C++ STD:：线程编写数组并行求和的代码。 但并行求和需要0.6秒，顺序求和需要0.3秒

我认为这段代码不会在

arr

或

ret

上进行任何同步

为什么会出现这种情况

我的CPU是i7-8700，它有6个物理内核

#include <stdio.h>
#include <ctime>
#include <thread>

// Constants
#define THREADS 4
#define ARR_SIZE 200000000
int ret[THREADS];

// Function for thread.
void parallel_sum(int *arr, int thread_id) {
    int s = ARR_SIZE / THREADS * thread_id, e = ARR_SIZE / THREADS * (thread_id + 1);
    printf("%d, %d\n", s, e);
    for (int i = s; i < e; i++) ret[thread_id] += arr[i];
}

int main() {

    // Variable definitions
    int *arr = new int[ARR_SIZE]; // 1 billion

    time_t t1, t2; // Variable for time consuming checking
    std::thread *threads = new std::thread[THREADS];

    // Initialization
    for (int i = 0; i < ARR_SIZE; i++) arr[i] = 1;
    for (int i = 0; i < THREADS; i++) ret[i] = 0;
    long long int sum = 0;

    // Parallel sum start
    t1 = clock();
    for (int i = 0; i < THREADS; i++) threads[i] = std::thread(parallel_sum, arr, i);
    for (int i = 0; i < THREADS; i++) threads[i].join();
    t2 = clock();

    for (int i = 0; i < THREADS; i++) sum += ret[i];
    printf("[%lf] Parallel sum %lld \n", (float)(t2 - t1) / (float)CLOCKS_PER_SEC, sum);
    // Parallel sum end


    sum = 0; // Initialization


    // Sequential sum start
    t1 = clock();
    for (int i = 0; i < ARR_SIZE; i++) sum += arr[i];
    t2 = clock();

    printf("[%lf] Sequential sum %lld \n", (float)(t2 - t1) / (float)CLOCKS_PER_SEC, sum);
    // Sequential sum end


    return 0;
}

#包括
#包括
#包括
//常数
#定义线程4
#定义ARR_大小200000
int ret[线程]；
//线程的函数。
无效并行线程和（int*arr，int线程id）{
int s=ARR_尺寸/螺纹*螺纹id，e=ARR_尺寸/螺纹*（螺纹id+1）；
printf（“%d，%d\n”，s，e）；
对于（inti=s；i

启用了编译器优化（其他任何方式的基准测试都没有意义），我得到了以下结果：

[0.093481]平行总和200000000
[0.073333]顺序总和200000000

注意，我们已经记录了这两种情况下的CPU总消耗量。这并不奇怪，并行求和会占用更多的总CPU，因为它必须启动线程并聚合结果。并行版本使用更多的CPU时间，因为它有更多的工作要做

您不会记录墙时间，但很可能是因为有四个内核参与了这项工作，所以在并行情况下，墙时间可能更少。添加代码来记录运行的挂机时间显示并行版本使用的挂机时间大约是串行版本的一半。至少，在我的机器上有合理的编译器优化设置

for (int i = s; i < e; i++) ret[thread_id] += arr[i];

或者，对于多线程求和，最好使用类型为

std:：atomic

的单个全局

ret

。然后，你可以简单地写：

int temp = 0;
for (int i = s; i < e; i++) temp += arr[i];
ret += temp;

---

现代编译器非常擅长优化，包括一些矢量化/并行化。看看生成的代码，看看会发生什么，以及这两种方法之间的区别。另外，您的系统有多少个CPU内核？您是否在并行求和上分析printf？另外，请阅读有关错误共享的信息。这：

ret[thread_id]+=arr[i]可能会导致大量缓存争用。最好在循环中更新一个局部变量，然后增加全局计数器（可能是原子计数器）。。。有很多事情可能会影响它。谢谢@丹尼尔·兰格。您的评论是对的。即使是最适度的优化，
ret[thread\u id]
实际上也不会写入循环中的每个迭代。@DavidSchwartz似乎不是这样：。虽然如果更新的变量（数组）不是函数本地的，我也会有同样的期望。@DavidSchwartz，但出于某些原因，编译器会将循环内更新写入每个循环中的内存（它甚至会阻止向量化）。与Clang和Intel相同：。如果
ret
是
int&
类型的参数，则相同。很有趣…很令人惊讶！这一定是有原因的。我无法想象他们只是不够聪明来执行优化。也许它不会提供任何好处，除非有虚假的分享。如果这个循环只运行了几次，并且没有错误的共享，那就是一种悲观情绪。@DavidSchwartz也让我感到惊讶。将就此问题发布一个单独的问题。这个明显的参考显示了一个关于挂钟时间和cpu时间之间差异的示例：
int temp = 0;
for (int i = s; i < e; i++) temp += arr[i];
ret += temp;

ret.fetch_add(temp, std::memory_order_relaxed);