CUDA kernel 用于确定比 OpenMP 代码慢的素数 - 我该如何优化它？

Question

为了在 C++ 中使用 CUDA 练习编程。我做了一个练习，其中包括显示小于 N 的素数。对于每个代码，我注释掉了最后一个显示循环以仅比较计算时间。

Makefile：

all: sum sum_cpu

nothing: 
    g++ -O3 -std=c++17 -o premier.exe premier.cpp -Wall
cpu:
    g++ -O3 -std=c++17 -o cpu_premier.exe premier.cpp -Wall -fopenmp  
gpu:
    nvcc  --compile --compiler-options -O3 -o gpu_premier.o gpu_premier.cu -gencode  arch=compute_50,code=sm_50
    nvcc --link --compiler-options -O3 -o gpu_premier.exe gpu_premier.o
clear: 
    rm *.exe *.o

这是我与 openMP 并行化的代码，运行时间为 1,306 秒：

#include <math.h>
#include <iostream>

const int N = 2<<22;
bool * premiers;

bool est_premier(int nbr){

    if ( nbr==1 || nbr == 0) return false;
    else if (nbr == 2) return true;
    else if (nbr % 2 == 0) return false;
    else {
        for (int i=3;i<=sqrt(nbr);++i){
            if (nbr % i == 0){
                return false;
            }
        }
    }
    return true;
}


int main(){
    premiers = new bool[N+1];

    # pragma omp parallel for
    for (int i = 0;i<N;++i){
        premiers[i] = est_premier(i);
    }

    /*
    for (int i = 0;i<N;++i){
        if (premiers[i])
            std::cout<<i<<",";
       
    } std::cout<<std::endl;
    */


    delete[] premiers;
}

这是在 1,613 秒内运行的相应 cuda 代码：

#include <cuda.h>
#include <iostream>
const int N = 2<<22;
bool * premiers_cpu;
bool * premiers_gpu;



__device__
bool est_premier(int nbr){

    if ( nbr==1 || nbr == 0) return false;
    else if (nbr == 2) return true;
    else if (nbr % 2 == 0) return false;
    else {
        for (int i=3;i * i <= nbr ;++i){
            if (nbr % i == 0){
                return false;
            }
        }
    }
    return true;
}


__global__ void kernel_premier(bool * premiers, int size){
    int gtid =  blockIdx.x * blockDim.x  + threadIdx.x ;

    while(gtid < size){
        premiers[gtid] = est_premier(gtid);
        gtid += blockDim.x * gridDim.x;
    }


}




int main(){

    bool * premiers_cpu = new bool[N];
   

    dim3 block (256,1);
    dim3 grid (2048,1,1);

    cudaMalloc(( void **) &premiers_gpu, N * sizeof(bool));
    cudaMemcpy(premiers_gpu,premiers_cpu,N * sizeof(bool),cudaMemcpyHostToDevice);

    kernel_premier<<<grid,block>>>(premiers_gpu,N);

    cudaMemcpy(premiers_cpu,premiers_gpu,N * sizeof(bool),cudaMemcpyDeviceToHost);

   
    /*
    for (int i = 0;i<N;++i){
        if (premiers_cpu[i])
            std::cout<<i<<",";
       
    } std::cout<<std::endl;
    */

    delete[] premiers_cpu;
    cudaFree(premiers_gpu);
    


}

直觉上，我认为降低网格的大小并增加每个网格的块数会使程序更有效率，但事实恰恰相反。 在这里，我在 cuda 中的程序比我使用 OpenMP 的程序效率低，如何解释它以及如何修复它？

Answer 1

好吧，首先，简单的观察：你甚至不应该在运行时计算它。 只需在编译时设置结果，运行时只是打印。

另外，第二个半琐碎的观察：确保你没有为打印计时。 终端 I/O 非常慢，也许这就是您花费大部分时间的原因？ 有两种选择？

最后，更重要的是：线程的发散会降低您的性能。 一半的线程甚至没有 go 进入循环，另外 1/6 只进行一次迭代 - 而平均而言，一个线程迭代 Theta(log((N)) 次。

但解决这个问题并不简单。 你最好的“选择”是完全切换你的算法（甚至可能在 CPU 上），并使用像Erathostenes 的筛子这样的东西：从因子开始，而不是潜在的素数，并标记非素数。 实际上，这也不是微不足道的并行化挑战。

无论如何，按原样使用算法，考虑更仔细的分离。 说...而不是提前返回 even nbr s - 不要迭代它们开始：不要检查gtid的素数，而是2*gtid + 1 ; 并将网格的大小减半。 当然，您可以对 CPU 执行相同的操作 - 但 GPU 会受益更多。

更一般地说，考虑将您的块大小设置为一个值，您可以从该值开始排除一些非素数并仅检查可疑对象。 例如，如果块大小为 5（这不是一个好主意。只是一个例子）那么您可以检查长度为 10 的数字运行的素数吗？ 为什么，因为在序列 10k,10k+1,10k+2,10k+3,10k+4,10k+5,10k+6,10k+7,10k+8,10k+9 - 第 1 个，第三，第五； 第 7 个和第 9 个数字是 2 的倍数。第 6 个（和第 1 个）是 5 的倍数，所以，线程的一半。 并在一定程度上减少了分歧。 更进一步（运行 2 3 5 个值，或 2 3 5*7），使用一个小的常量查找表来选择要检查的值，您会看到一些改进。

警告：这可能仍然不是你最大的敌人。 始终使用分析（例如使用 nsight-compute）来查看您将大部分时间花在哪里以及如何花。