CUDA:有更快的方式写入全局内存吗?

时间:2016-08-10 15:26:32

标签: c++ cuda

我正在编写一个n体仿真,基本上整个操作是:

applicationUser

我注意到将近90%的时间用于将数据写入内核中的全局设备内存。这是内核:

-Prepare CUDA memory
 loop {
    -Copy data to CUDA
    -Launch kernel
    -Copy data to host
    -Operations using data (drawing etc.)
 }

运行它的设备是GTX 970.执行所需的时间大约为8.0秒,但是在添加这些标志后: -gencode arch = compute_52,code = sm_52 ,性能提升到6.7秒左右。在注释掉写入全局设备内存的代码之后:

 __global__ void calculateForcesCuda(float *deviceXpos, float *deviceYpos, float *deviceZpos,
                                    float *deviceXforces, float *deviceYforces, float *deviceZforces,
                                    float *deviceMasses, int particlesNumber) {
     int tid = threadIdx.x + blockIdx.x * blockDim.x;
     if (tid <= particlesNumber) {
         float particleXpos = deviceXpos[tid];
         float particleYpos = deviceYpos[tid];
         float particleZpos = deviceZpos[tid];
         float xForce = 0.0f;
         float yForce = 0.0f;
         float zForce = 0.0f;
         for (int index=0; index<particlesNumber; index++) {
             if (tid != index) {
                 float otherXpos = deviceXpos[index];
                 float otherYpos = deviceYpos[index];
                 float otherZpos = deviceZpos[index];
                 float mass = deviceMasses[index];
                 float distx = particleXpos - otherXpos;
                 float disty = particleYpos - otherYpos;
                 float distz = particleZpos - otherZpos;
                 float distance = sqrt((distx*distx + disty*disty + distz*distz) + 0.01f);
                 xForce += 10.0f * mass / distance * (otherXpos - particleXpos);
                 yForce += 10.0f * mass / distance * (otherYpos - particleYpos);
                 zForce += 10.0f * mass / distance * (otherZpos - particleZpos);
             }
         }
         deviceXforces[tid] += xForce;
         deviceYforces[tid] += yForce;      
         deviceZforces[tid] += zForce;
     }
 }

...总执行时间减少到大约0.92秒,这意味着写入全局设备内存大约需要86%的执行时间。有没有办法可以提高这些写入的性能?

1 个答案:

答案 0 :(得分:2)

在这种计算中,记忆通常是瓶颈,即使你测量的时间不是90%。我会建议两件事。

device...[index]加载到共享内存

目前,所有线程都读取相同的deviceXpos[index]deviceYpos[index]deviceZpos[index]deviceMasses[index]。相反,您可以将它们加载到共享内存中:

static const int blockSize = ....;

__shared__ float shXpos[blockSize];
__shared__ float shYpos[blockSize];
__shared__ float shZpos[blockSize];
__shared__ float shMasses[blockSize];
for (int mainIndex=0; mainIndex<particlesNumber; index+=blockSize) {
    __syncthreads(); //ensure computation from previous iteration has completed
    shXpos[threadIdx.x] = deviceXpos[mainIndex + threadIdx.x];
    shYpos[threadIdx.x] = deviceYpos[mainIndex + threadIdx.x];
    shZpos[threadIdx.x] = deviceZpos[mainIndex + threadIdx.x];
    shMasses[threadIdx.x] = deviceMasses[mainIndex + threadIdx.x];
    __syncthreads(); //ensure all data is read before computation starts
    for (int index=0; index<blockSize; ++index) {
        .... //your computation, using sh....[index] values
    }
}

这应该减少全局内存读取的数量,因为每个线程读取不同的数据,而不是所有读取相同的东西。

请注意,如果驱动程序正确管理L1缓存,则此建议可能不会那么有效。试试吧!

每个线程处理多于1个(接收)粒子

您可能希望一次执行多个粒子的计算。而不是只有一组{particleX/Y/Zposx/y/zForce},代表一个接收力的粒子,你可以同时拥有其中的一些。 这样,通过在循环中加载源一次,就可以处理多个接收器。

这可能会显着降低您的记忆力,但同时会增加您的记录计数。太多的寄存器 - 你将无法启动那么多线程。

检查您的线程已有多少个寄存器,并查阅CUDA占用计算器以查看您可以使用多少寄存器。也许可以将占用率从1降低到0.5或0.75,但同时处理更多颗粒将是有益的?您需要进行实验,因为这可能因GPU而异。