Question

我用C ++ std :: thread编写了数组并行求和的代码。但是并行和需要0.6s，顺序和需要0.3s。

我认为这段代码不会对arr或ret进行任何同步。

为什么会发生这种情况？

我的CPU是具有6个物理内核的i7-8700。

#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;
}

Answer 1

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

这会导致大量缓存争用，因为ret数组的元素可能共享同一缓存行。通常称为虚假共享。

一个简单的解决方法是使用一个辅助（线程）局部变量进行循环更新，然后最终增加共享计数器，例如：

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

或者，最好将类型为ret的单个全局std::atomic<int>用于多线程和。然后，您只需编写：

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

或者，甚至更有效地：

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

Answer 2

启用编译器优化（以其他方式进行基准测试毫无意义），我得到以下结果：

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

请注意，在两种情况下，我们都记录了总计的CPU消耗。并行求和使用更多的总CPU并不奇怪，因为它必须启动线程并汇总结果。并行版本使用更多的CPU时间，因为它要做的工作更多。

您无需记录挂墙时间，但是很可能由于四个核心有助于完成这项工作，因此并行情况下的挂墙时间可能更少。添加代码以记录经过的挂墙时间，可以发现并行版本使用的串行时间大约是串行版本的一半。至少在我的机器上具有合理的编译器优化设置。

数组的并行求和比C ++中的顺序求和慢

2 个答案: