Question

我想用CUDA语言编写一个电磁二维有限差分时域（FDTD）代码。用于更新磁场的C代码如下

// --- Update for Hy and Hx
for(int i=n1; i<=n2; i++)
   for(int j=n11; j<=n21; j++){
      Hy[i*ydim+j]=A[i*ydim+j]*Hy[i*ydim+j]+B[i*ydim+j]*(Ezx[(i+1)*ydim+j]-Ezx[i*ydim+j]+Ezy[(i+1)*ydim+j]-Ezy[i*ydim+j]);
  Hx[i*ydim+j]=G[i*ydim+j]*Hx[i*ydim+j]-H[i*ydim+j]*(Ezx[i*ydim+j+1]-Ezx[i*ydim+j]+Ezy[i*ydim+j+1]-Ezy[i*ydim+j]);
   }
}

我的第一次并行化尝试是以下内核：

__global__ void H_update_kernel(double* Hx_h, double* Hy_h, double* Ezx_h, double* Ezy_h, double* A_h, double* B_h,double* G_h, double* H_h, int n1, int n2, int n11, int n21)
{
   int idx = blockIdx.x*BLOCK_SIZE_X + threadIdx.x;
   int idy = blockIdx.y*BLOCK_SIZE_Y + threadIdx.y;

   if ((idx <= n2 && idx >= n1)&&(idy <= n21 && idy >= n11)) {
      Hy_h[idx*ydim+idy]=A_h[idx*ydim+idy]*Hy_h[idx*ydim+idy]+B_h[idx*ydim+idy]*(Ezx_h[(idx+1)*ydim+idy]-Ezx_h[idx*ydim+idy]+Ezy_h[(idx+1)*ydim+idy]-Ezy_h[idx*ydim+idy]);
  Hx_h[idx*ydim+idy]=G_h[idx*ydim+idy]*Hx_h[idx*ydim+idy]-H_h[idx*ydim+idy]*(Ezx_h[idx*ydim+idy+1]-Ezx_h[idx*ydim+idy]+Ezy_h[idx*ydim+idy+1]-Ezy_h[idx*ydim+idy]); }

}

然而，通过使用Visual Profiler，我对此解决方案不满意，原因有两个： 1）内存访问合并不良; 2）不使用共享内存。

然后我决定使用以下解决方案

__global__ void H_update_kernel(double* Hx_h, double* Hy_h, double* Ezx_h, double* Ezy_h, double* A_h, double* B_h,double* G_h, double* H_h, int n1, int n2, int n11, int n21)
{
    int i       = threadIdx.x;
int j       = threadIdx.y;
int idx     = blockIdx.x*BLOCK_SIZE_X + threadIdx.x;
int idy     = blockIdx.y*BLOCK_SIZE_Y + threadIdx.y;

int index1  = j*BLOCK_SIZE_Y+i;

int i1      = (index1)%(BLOCK_SIZE_X+1);
int j1      = (index1)/(BLOCK_SIZE_Y+1);

int i2      = (BLOCK_SIZE_X*BLOCK_SIZE_Y+index1)%(BLOCK_SIZE_X+1);
int j2      = (BLOCK_SIZE_X*BLOCK_SIZE_Y+index1)/(BLOCK_SIZE_Y+1);

__shared__ double Ezx_h_shared[BLOCK_SIZE_X+1][BLOCK_SIZE_Y+1];     
__shared__ double Ezy_h_shared[BLOCK_SIZE_X+1][BLOCK_SIZE_Y+1];     

if (((blockIdx.x*BLOCK_SIZE_X+i1)<xdim)&&((blockIdx.y*BLOCK_SIZE_Y+j1)<ydim))
    Ezx_h_shared[i1][j1]=Ezx_h[(blockIdx.x*BLOCK_SIZE_X+i1)*ydim+(blockIdx.y*BLOCK_SIZE_Y+j1)];

if (((i2<(BLOCK_SIZE_X+1))&&(j2<(BLOCK_SIZE_Y+1)))&&(((blockIdx.x*BLOCK_SIZE_X+i2)<xdim)&&((blockIdx.y*BLOCK_SIZE_Y+j2)<ydim)))
    Ezx_h_shared[i2][j2]=Ezx_h[(blockIdx.x*BLOCK_SIZE_X+i2)*xdim+(blockIdx.y*BLOCK_SIZE_Y+j2)];

__syncthreads();

if ((idx <= n2 && idx >= n1)&&(idy <= n21 && idy >= n11)) {
    Hy_h[idx*ydim+idy]=A_h[idx*ydim+idy]*Hy_h[idx*ydim+idy]+B_h[idx*ydim+idy]*(Ezx_h_shared[i+1][j]-Ezx_h_shared[i][j]+Ezy_h[(idx+1)*ydim+idy]-Ezy_h[idx*ydim+idy]);
    Hx_h[idx*ydim+idy]=G_h[idx*ydim+idy]*Hx_h[idx*ydim+idy]-H_h[idx*ydim+idy]*(Ezx_h_shared[i][j+1]-Ezx_h_shared[i][j]+Ezy_h[idx*ydim+idy+1]-Ezy_h[idx*ydim+idy]); }

    }

需要索引技巧以使BS_x * BS_y线程的块读取（BS_x + 1）*（BS_y + 1）全局存储器位置到共享存储器。我相信这个选择比前一个更好，因为共享内存的使用，虽然不是所有的访问都真的合并，请参阅

Analyzing memory access coalescing of my CUDA kernel

我的问题是，如果你们中的任何人能够在合并内存访问方面找到更好的解决方案。谢谢。

Answer 1

感谢您提供分析信息。

你的第二个算法更好，因为你获得了更高的IPC。尽管如此，在CC 2.0上，最大IPC是2.0，因此在第二个1.018解决方案中的平均值意味着只有一半的可用计算能力被利用。通常，这意味着您的算法是内存绑定的，但我不确定您的情况，因为内核中的几乎所有代码都在if条件内。大量的扭曲分歧会影响性能，但我没有检查是否将使用的结果指向IPC。

您可能希望通过纹理缓存进行阅读。纹理针对2D空间局部性进行了优化，并且更好地支持半随机2D访问。它可能有助于您[i][j]类型的访问。

在当前的解决方案中，确保它是Y位置（[j]），它在具有相邻线程ID的两个线程之间进行最小的更改（以尽可能地保持内存访问）。

可能是编译器已经为您优化了这一点，但您多次重新计算idx*ydim+idy。尝试计算一次并重复使用结果。如果您的算法是计算绑定的话，那将有更大的改进潜力。

Answer 2

我相信在这种情况下你的第一个并行解决方案更好，因为每个线程只读取一次全局内存数组元素。因此，将这些阵列存储在共享内存中并不会带来预期的改进。

由于在共享内存中存储数据期间更好地合并访问全局内存，它可以加速您的程序，但如果您使用Compute Capability 2.x并且还使用共享内存，则通过缓存全局内存访问来平衡IMHO因银行冲突而被降级。

CUDA中的二维有限差分时域（FDTD）

2 个答案: