多线程不会提高递归 C++ 程序的性能

Question

考虑这个递归多线程程序：

#include <iostream>
#include <thread>

#define NUMTHREADS 4
using namespace std;

int g[NUMTHREADS];

thread t[NUMTHREADS];

void task1(int x)
{
    if(x+1<NUMTHREADS)
        t[x] = thread(task1, x+1);
    for(int i=0;i<100000000;i++)
        g[x]++;
    if(x+1<NUMTHREADS)
        t[x].join();
}

int main()
{
    task1(0);
    for(int i=0;i<NUMTHREADS;i++)
        cout<<g[i]<<" ";
}

我预计线程开销是微不足道的，但实际上程序的运行时间随着线程数线性增加。

这是我的 6 核 cpu 的一些计时：

NUMTHREADS = 1：

$ time ./a
100000000
real    0m0.330s
user    0m0.312s
sys     0m0.015s

NUMTHREADS = 2：

$ time ./a
100000000 100000000
real    0m0.742s
user    0m1.404s
sys     0m0.015s

NUMTHREADS = 3：

$ time ./a
100000000 100000000 100000000
real    0m1.038s
user    0m2.792s
sys     0m0.000s

NUMTHREADS = 4：

$ time ./a
100000000 100000000 100000000 100000000
real    0m1.511s
user    0m5.616s
sys     0m0.015s

知道为什么会这样吗？

Answer 1

由于在访问g 的元素时出现错误共享的极端情况，线程程序的执行正在被序列化。这是您的程序的修改版本，它可以避免虚假共享，并使用不同数量的线程运行相同的时间，只要每个线程可以分配给不同的 CPU 内核：

#include <iostream>
#include <thread>

#define NUMTHREADS 4
using namespace std;

int g[NUMTHREADS*16];

thread t[NUMTHREADS];

void task1(int x)
{
    if(x+1<NUMTHREADS)
        t[x] = thread(task1, x+1);
    for(int i=0;i<100000000;i++)
        g[x*16]++;
    if(x+1<NUMTHREADS)
        t[x].join();
}

int main()
{
    task1(0);
    for(int i=0;i<NUMTHREADS;i++)
        cout<<g[i*16]<<" ";
}

1 个线程和 4 个线程的运行时间：

$ time ./a.out
100000000
./a.out  0.45s user 0.01s system 98% cpu 0.466 total
                                         ^^^^^^^^^^^
$ time ./a.out
100000000 100000000 100000000 100000000
./a.out  1.52s user 0.01s system 329% cpu 0.462 total
                                          ^^^^^^^^^^^

下面是对所发生情况的简短说明。现代 x86 CPU 以 64 字节的块访问主内存，称为 缓存行（除非使用非临时存储或加载指令，但这里不是这种情况）。该大小的单个高速缓存行最多可容纳 int 数组的 16 个元素：

|    single cache line      |  another cache line
|------+------+-----+-------|-------+-------+------
| g[0] | g[1] | ... | g[15] | g[16] | g[17] | ...
+------+------+-----+-------+-------+-------+------
    ^      ^
    |      |
    |      +------ thread 1 updates this element
    |
    +------------- thread 0 updates this element

x86 是一个缓存一致性架构，这意味着当一个缓存行在单个内核中被修改时，其他内核会被告知它们对同一缓存行的副本不再有效，并且必须从上层内存存储重新加载，例如共享的 L3 缓存或主内存。由于共享的最后一级缓存和主内存都比每个内核的私有缓存慢得多，这会导致执行速度慢得多。

修改后的版本将g中的索引乘以16：

|     one cache line        |  another cache line
|------+------+-----+-------|-------+-------+------
| g[0] | g[1] | ... | g[15] | g[16] | g[17] | ...
+------+------+-----+-------+-------+-------+------
    ^                           ^
    |                           |
    |                           +------ thread 1 updates this element
    |
    +------------- thread 0 updates this element

现在很清楚，没有两个线程共享同一个缓存行，因此缓存一致性协议不参与该进程。

使用堆栈变量时也可以达到同样的效果。线程堆栈通常很大（至少几个 KiB）并且在内存页面边界上对齐，因此不同线程中的堆栈变量永远不会共享相同的缓存行。此外，编译器还进一步优化了对堆栈变量的访问。

请参阅this answer 以获得更彻底的解释以及防止虚假共享的另一种方法。虽然它是关于 OpenMP，但这些概念也适用于您的案例。

Answer 2

你应该：

1. 使用至少 -O2 优化编译您的代码。

2. 声明变体g为volatile，否则编译时可能会被优化掉。

在我的 2 核机器上，thread=1 和 thread=2 的成本几乎相同。

Answer 3

我相信在创建和加入这样的线程时会有很多开销（请参阅这个问题C++11: std::thread pooled?）。如果您想通过并行化提高效率，请查看 OpenMP 之类的东西。

Answer 4

线程在彼此并行的单独内核上运行时会提高性能。因此，通过将线程关联设置到不同的核心，将每个线程绑定到不同的核心。 可能您的线程在单核上运行。

所以如果线程 1,2,3,4 分配给 diff cores 1 2 3 4（不要使用 0），那么所有的都会同时增加索引。请参阅$cpuinfo 以查看处理器的内核。并使用thread->setAffinity(core_numer); 设置线程的核心。