c - Intel(x86_64) 64位与32位整数运算性能差异

Question

我正在测试一些程序，发现了一个相当意外的异常情况。

我编写了一个简单的程序来计算素数，并使用 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->t,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 位算术慢吗？

Answer 1

一般来说，64 位算术与 32 位一样快，忽略较大的操作数占用更多内存和 BW(带宽)等问题，并且在 x86-64 上寻址完整的 64 位寄存器需要更长的指令。

但是，您已经成功地遇到了此规则的少数异常(exception)之一，即用于计算除法的 div 指令。