c-有线程的代码比没有线程的代码花费更长的时间

Question

我正在C中尝试线程，但我对一些结果感到困惑。

我有以下循环：

for(size_t i=0;i<1000000000;i++){
a++;
}

它递增全局变量a。我使用了6个变量，a到e。

首先，我在main:中连续递增变量

#include<stdio.h>
#include<pthread.h>
size_t a,b,c,d,e,f;
int main(void){
for(size_t i=0;i<1000000000;i++){
a++;
}
for(size_t i=0;i<1000000000;i++){
b++;
}
for(size_t i=0;i<1000000000;i++){
c++;
}
for(size_t i=0;i<1000000000;i++){
d++;
}
for(size_t i=0;i<1000000000;i++){
e++;
}
for(size_t i=0;i<1000000000;i++){
f++;
}
size_t abcdef=a+b+c+d+e+f;
printf("%zun",abcdef);
return 0;
}

然后，在用time测试程序时，给出了以下结果：

6000000000
real    0m11.450s
user    0m11.446s
sys     0m0.000s

我希望使用pthreads的结果会快一点：

#include<stdio.h>
#include<pthread.h>
size_t a,b,c,d,e,f;
void *t1(void *args){
for(size_t i=0;i<1000000000;i++){
a++;
}
return NULL;
}
void *t2(void *args){
for(size_t i=0;i<1000000000;i++){
b++;
}
return NULL;
}
void *t3(void *args){
for(size_t i=0;i<1000000000;i++){
c++;
}
return NULL;
}
void *t4(void *args){
for(size_t i=0;i<1000000000;i++){
d++;
}
return NULL;
}
void *t5(void *args){
for(size_t i=0;i<1000000000;i++){
e++;
}
return NULL;
}
void *t6(void *args){
for(size_t i=0;i<1000000000;i++){
f++;
}
return NULL;
}
int main(void){
pthread_t p1,p2,p3,p4,p5,p6;
pthread_create(&p1,NULL,t1,NULL);
pthread_create(&p2,NULL,t2,NULL);
pthread_create(&p3,NULL,t3,NULL);
pthread_create(&p4,NULL,t4,NULL);
pthread_create(&p5,NULL,t5,NULL);
pthread_create(&p6,NULL,t6,NULL);
pthread_join(p1,NULL);
pthread_join(p2,NULL);
pthread_join(p3,NULL);
pthread_join(p4,NULL);
pthread_join(p5,NULL);
pthread_join(p6,NULL);
size_t abcdef=a+b+c+d+e+f;
printf("%zun",abcdef);
return 0;
}

然而，结果完全出乎意料：

6000000000
real    0m14.521s
user    1m26.048s
sys     0m0.014s

不仅实时时间更大，我预计会更低，而且用户时间超过1分钟，我没有等一分钟。

这里发生了什么？我该如何解决？

Answer 1

您在这里遇到的问题是由于缓存一致性。

在现代处理器中，单个内核一次可以访问的实际最小内存量是一条完整的缓存线，在许多现代处理器上是64字节。这意味着，每个变量的每一个增量，都会读取64个字节，其中8个字节会根据增量进行修改。其他56个字节正好可以使用。

然而，如果这些其他字节中的任何一个需要由另一个内核修改，它们必须使用缓存一致性协议来确保它们不会损坏彼此的内存。当一个缓存行被写入时，它将被标记为已修改，并且每个其他缓存都必须将其标记为无效并重新加载才能再次使用。

当您将代码中的变量定义为：

size_t a,b,c,d,e,f;

它们都在内存中排列为一个连续的块，最终将小于一个完整的缓存行。这意味着每个线程都在争夺那一块64字节的内存，在获得内存之前无法进行。这使得实际执行是串行的，即使多个内核可能同时执行代码。

以下是我运行程序的结果：(test是您的第一个代码示例，test1是pthreads示例(

$ time ./test
6000000000
real    0m22.526s
user    0m22.391s
sys     0m0.000s
$ time ./test1
6000000000
real    0m13.094s
user    1m7.797s
sys     0m0.047s

我的pthreads测试实际上更快。我怀疑这是由于我的CPU使用超线程，它实际上在同一个核心上运行两个线程，共享同一个缓存线，因此没有争用。

我修改了pthreads代码，使用编译器指令使全局变量64字节对齐，强制每个全局变量都在自己的缓存行中。

size_t a __attribute__ ((aligned (64)));
size_t b __attribute__ ((aligned (64)));
size_t c __attribute__ ((aligned (64)));
size_t d __attribute__ ((aligned (64)));
size_t e __attribute__ ((aligned (64)));
size_t f __attribute__ ((aligned (64)));

结果如下：

$ time ./test2
6000000000
real    0m2.665s
user    0m15.281s
sys     0m0.016s

速度快多了！

Answer 2

不确定。。但是在线程化的情况下，线程创建、线程终止和库初始化将需要一些时间。所以这可能就是原因。您可以尝试在每个线程函数的循环前后以及主线程中所有循环前后打印时间。