问题描述
我在测试某个程序时遇到了一个相当出乎意料的异常。
我编写了一个简单的程序来计算素数,并使用 pthreads API 来并行化这个工作负载。
在进行一些测试后,我发现如果我使用 uint64_t 作为计算和循环的数据类型,程序运行的时间比使用 uint32_t 的时间要长得多。
这是我运行的代码:
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <pthread.h>
#define UINT uint64_t
#define SIZE (1024 * 1024)
typedef struct _data
{
UINT start;
UINT len;
int t;
UINT c;
}data;
int isprime(UINT x)
{
uint8_t flag = 1;
if(x < 2)
return 0;
for(UINT i = 2;i < x/2; i++)
{
if(!(x % i ))
{
flag = 0;
break;
}
}
return flag;
}
void* calc(void *p)
{
data *a = (data*)p;
//printf("thread no. %d has start: %lu length: %lu\n",a->t,a->start,a->len);
for(UINT i = a->start; i < a->len; i++)
{
if(isprime(i))
a->c++;
}
//printf("thread no. %d found %lu primes\n",a->c);
pthread_exit(NULL);
}
int main(int argc,char **argv)
{
pthread_t *t;
data *a;
uint32_t THREAD_COUNT;
if(argc < 2)
THREAD_COUNT = 1;
else
sscanf(argv[1],"%u",&THREAD_COUNT);
t = (pthread_t*)malloc(THREAD_COUNT * sizeof(pthread_t));
a = (data*)malloc(THREAD_COUNT * sizeof(data));
printf("executing the application on %u thread(s).\n",THREAD_COUNT);
for(uint8_t i = 0; i < THREAD_COUNT; i++)
{
a[i].t = i;
a[i].start = i * (SIZE / THREAD_COUNT);
a[i].len = a[i].start + (SIZE / THREAD_COUNT);
a[i].c = 0;
}
for(uint8_t i = 0; i < THREAD_COUNT; i++)
pthread_create(&t[i],NULL,calc,(void*)&a[i]);
for(uint8_t i = 0; i < THREAD_COUNT; i++)
pthread_join(t[i],NULL);
free(a);
free(t);
return 0;
}
我在 uint32_t 和 uint64_t 之间更改了 UINT 宏,并编译并运行了该程序,并在 linux 上使用 time 命令确定了其运行时间。
我发现 uint64_t 与 uint32_t 的运行时之间存在重大差异。
使用 uint32_t 需要 46s 运行程序,而使用 uint64_t 需要 2m49s 运行!
我在这里写了一篇关于它的博文:https://qcentlabs.com/index.php/2021/02/01/intelx86_64-64-bit-vs-32-bit-arithmetic-big-performance-difference/
如果您想了解更多信息,可以查看帖子。
这背后的问题可能是什么? x86_64 上的 64 位算术比 32 位算术慢吗?
解决方法
一般来说,64 位算术与 32 位算术一样快,忽略诸如占用更多内存和 BW 的较大操作数之类的事情,并且在 x86-64 上寻址完整的 64 位寄存器需要更长的指令。
但是,您已经设法找到了这条规则的少数例外之一,即用于计算除法的 div
指令。