使用AoS的内核比使用SoA更快

Question

我有两个版本的内核执行相同的任务-填充链接的单元格列表-，两个内核之间的区别是用于存储粒子位置的数据类型，第一个使用float数组存储位置（每个粒子4个float到128位的读取/写入），第二个使用vec3f结构数组存储位置（该结构包含3个浮点数）。

使用nvprof进行了一些测试，我发现第二个内核（使用vec3f）的运行速度比第一个更快：

 Time(%)      Time   Calls       Avg       Min       Max  Name
   42.88    37.26s       2    18.63s   23.97us    37.26s  adentu_grid_cuda_filling_kernel(int*, int*, int*, float*, int, _vec3f, _vec3f, _vec3i)
   11.00     3.93s       2     1.97s   25.00us     3.93s  adentu_grid_cuda_filling_kernel(int*, int*, int*, _vec3f*, int, _vec3f, _vec3f, _vec3i)

尝试使用256和512000粒子填充链接的单元格列表以完成测试。

我的问题是，这里发生了什么？ 我认为，由于使用了合并的内存，因此与使用未对齐内存的vec3f结构数组相比，浮动数组应该可以实现更好的内存访问。 我误会了什么？

这些是内核，第一个内核：

__global__ void adentu_grid_cuda_filling_kernel (int *head,
                                                 int *linked,
                                                 int *cellnAtoms,
                                                 float *pos, 
                                                 int nAtoms, 
                                                 vec3f origin, 
                                                 vec3f h,
                                                 vec3i nCell)
{
    int idx = threadIdx.x + blockIdx.x * blockDim.x;
    if (idx >= nAtoms)
        return;

    vec3i cell;
    vec3f _pos = (vec3f){(float)pos[idx*4+0], (float)pos[idx*4+1], (float)pos[idx*4+2]};

    cell.x =  floor ((_pos.x - origin.x)/h.x);
    cell.y =  floor ((_pos.y - origin.y)/h.y);
    cell.z =  floor ((_pos.z - origin.z)/h.z);

    int c = nCell.x * nCell.y * cell.z + nCell.x * cell.y + cell.x;

    int i;
    if (atomicCAS (&head[c], -1, idx) != -1){
        i = head[c];
        while (atomicCAS (&linked[i], -1, idx) != -1)
                i = linked[i];
    }
    atomicAdd (&cellnAtoms[c], 1);
}

这是第二个内核：

__global__ void adentu_grid_cuda_filling_kernel (int *head,
                                                 int *linked,
                                                 int *cellNAtoms,
                                                 vec3f *pos,
                                                 int nAtoms,
                                                 vec3f origin,
                                                 vec3f h,
                                                 vec3i nCell)
{
    int idx = threadIdx.x + blockIdx.x * blockDim.x;
    if (idx >= nAtoms)
        return;

    vec3i cell;
    vec3f _pos = pos[idx];

    cell.x = floor ((_pos.x - origin.x)/h.x);
    cell.y = floor ((_pos.y - origin.y)/h.y);
    cell.z = floor ((_pos.z - origin.z)/h.z);

    int c = nCell.x * nCell.y * cell.z + nCell.x * cell.y + cell.x;

    int i;
    if (atomicCAS (&head[c], -1, idx) != -1){
        i = head[c];
        while (atomicCAS (&linked[i], -1, idx) != -1)
                i = linked[i];
    }
    atomicAdd (&cellNAtoms[c], 1);
}

这是vec3f结构：

typedef struct _vec3f {float x, y, z} vec3f;

Answer 1

这不是AoS与SoA的示例。 让我们看一下重要的代码行以及其中隐含的数据结构。

您的第一个“ SoA”或“慢”案例：

vec3f _pos = (vec3f){(float)pos[idx*4+0], (float)pos[idx*4+1], (float)pos[idx*4+2]};
                                      ^                    ^                    ^
                                      |                    |                    |
                               These values are stored in *adjacent* memory locations

因此，一个线程正在依次访问pos[idx*4]及其后的2个位置。 这就是结构的存储方式！ 您所说的数组结构实际上是结构数组，即存储在内存中的方式。 要使用有效的“ SoA”案例，您的代码将需要如下所示：

vec3f _pos = (vec3f){(float)pos1[idx], (float)pos2[idx], (float)pos3[idx]};
                                 ^
                                 |
               Adjacent threads will read adjacent values for pos1, pos2, and pos3
                    leading to *coalesced* access.

您的“ AoS”或“快速”实际上没有其他存储格式。

Answer 2

在我看来，这两种方法实际上都是AoS，唯一的区别是第一种方法是具有四个元素的结构的AoS，而第二种方法仅使用了三个元素。 这就是为什么您的第二个解决方案更可取的原因。

如果您真的想在第一个解决方案中使用SoA，则必须按以下方式组织pos数组：

vec3f _pos = (vec3f){(float)pos[idx], (float)pos[N + idx], (float)pos[2 * N + idx]};