Question

根据我在此处阅读的一些评论，由于某些原因，最好让Structure of Arrays（SoA）优先于Array of Structures（AoS）进行并行实施，例如CUDA？如果这是真的，谁能解释为什么？提前谢谢！

Answer 1

选择AoS与SoA以获得最佳性能通常取决于访问模式。然而，这不仅限于CUDA - 类似的考虑因素适用于性能可能受存储器访问模式显着影响的任何体系结构，例如，你有缓存的地方或连续内存访问性能更好的地方（例如CUDA中的合并内存访问）。

E.g。对于RGB像素与单独的RGB平面：

struct {
    uint8_t r, g, b;
} AoS[N];

struct {
    uint8_t r[N];
    uint8_t g[N];
    uint8_t b[N];
} SoA;

如果您要同时访问每个像素的R / G / B组件，那么AoS通常是有意义的，因为R，G，B组件的连续读取将是连续的并且通常包含在同一缓存行中。对于CUDA，这也意味着内存读/写合并。

但是，如果您要单独处理彩色平面，则可能首选SoA，例如如果你想按比例因子缩放所有R值，那么SoA意味着所有R分量都是连续的。

另一个考虑因素是填充/对齐。对于上面的RGB示例，AoS布局中的每个元素都对齐到3个字节的倍数，这对于CUDA，SIMD等可能不方便 - 在某些情况下甚至可能需要在结构内填充以使对齐更方便（例如，添加一个虚拟uint8_t元素以确保4字节对齐）。然而，在SoA情况下，平面是字节对齐的，这对某些算法/架构来说更方便。

对于大多数图像处理类型的应用程序，AoS场景更为常见，但对于其他应用程序或特定图像处理任务，情况可能并非总是如此。如果没有明显的选择，我会推荐AoS作为默认选择。

有关AoS v SoA的更多一般性讨论，另请参阅this answer。

Answer 2

我只是想提供一个简单的例子，展示阵列结构（SoA）如何比结构数组（AoS）表现得更好。

在这个例子中，我考虑了相同代码的三个不同版本：

SoA（v1）
直线阵列（v2）
AoS（v3）

特别是，版本xx = structure(list(id = 1:4, hour = structure(c(3L, 2L, 4L, 1L), .Label = c("06:30", "12:10", "15:10", "22:10"), class = "factor")), .Names = c("id", "hour"), row.names = c(NA, -4L), class = "data.frame")考虑使用直接数组。版本2和2的时间安排与此示例相同，结果优于版本3。我怀疑，一般来说，直接数组可能更好，但是以可读性为代价，因为，例如，在这种情况下，可以通过1启用从统一缓存加载。

const __restrict__

以下是时间（在GTX960上执行的运行）：

#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>

#include <thrust\device_vector.h>

#include "Utilities.cuh"
#include "TimingGPU.cuh"

#define BLOCKSIZE   1024

/******************************************/
/* CELL STRUCT LEADING TO ARRAY OF STRUCT */
/******************************************/
struct cellAoS {

    unsigned int    x1;
    unsigned int    x2;
    unsigned int    code;
    bool            done;

};

/*******************************************/
/* CELL STRUCT LEADING TO STRUCT OF ARRAYS */
/*******************************************/
struct cellSoA {

    unsigned int    *x1;
    unsigned int    *x2;
    unsigned int    *code;
    bool            *done;

};


/*******************************************/
/* KERNEL MANIPULATING THE ARRAY OF STRUCT */
/*******************************************/
__global__ void AoSvsSoA_v1(cellAoS *d_cells, const int N) {

    const int tid = threadIdx.x + blockIdx.x * blockDim.x;

    if (tid < N) {
        cellAoS tempCell = d_cells[tid];

        tempCell.x1 = tempCell.x1 + 10;
        tempCell.x2 = tempCell.x2 + 10;

        d_cells[tid] = tempCell;
    }

}

/******************************/
/* KERNEL MANIPULATING ARRAYS */
/******************************/
__global__ void AoSvsSoA_v2(unsigned int * __restrict__ d_x1, unsigned int * __restrict__ d_x2, const int N) {

    const int tid = threadIdx.x + blockIdx.x * blockDim.x;

    if (tid < N) {

        d_x1[tid] = d_x1[tid] + 10;
        d_x2[tid] = d_x2[tid] + 10;

    }

}

/********************************************/
/* KERNEL MANIPULATING THE STRUCT OF ARRAYS */
/********************************************/
__global__ void AoSvsSoA_v3(cellSoA cell, const int N) {

    const int tid = threadIdx.x + blockIdx.x * blockDim.x;

    if (tid < N) {

        cell.x1[tid] = cell.x1[tid] + 10;
        cell.x2[tid] = cell.x2[tid] + 10;

    }

}

/********/
/* MAIN */
/********/
int main() {

    const int N = 2048 * 2048 * 4;

    TimingGPU timerGPU;

    thrust::host_vector<cellAoS>    h_cells(N);
    thrust::device_vector<cellAoS>  d_cells(N);

    thrust::host_vector<unsigned int>   h_x1(N);
    thrust::host_vector<unsigned int>   h_x2(N);

    thrust::device_vector<unsigned int> d_x1(N);
    thrust::device_vector<unsigned int> d_x2(N);

    for (int k = 0; k < N; k++) {

        h_cells[k].x1 = k + 1;
        h_cells[k].x2 = k + 2;
        h_cells[k].code = k + 3;
        h_cells[k].done = true;

        h_x1[k] = k + 1;
        h_x2[k] = k + 2;

    }

    d_cells = h_cells;

    d_x1 = h_x1;
    d_x2 = h_x2;

    cellSoA cell;
    cell.x1 = thrust::raw_pointer_cast(d_x1.data());
    cell.x2 = thrust::raw_pointer_cast(d_x2.data());
    cell.code = NULL;
    cell.done = NULL;

    timerGPU.StartCounter();
    AoSvsSoA_v1 << <iDivUp(N, BLOCKSIZE), BLOCKSIZE >> >(thrust::raw_pointer_cast(d_cells.data()), N);
    gpuErrchk(cudaPeekAtLastError());
    gpuErrchk(cudaDeviceSynchronize());
    printf("Timing AoSvsSoA_v1 = %f\n", timerGPU.GetCounter());

    //timerGPU.StartCounter();
    //AoSvsSoA_v2 << <iDivUp(N, BLOCKSIZE), BLOCKSIZE >> >(thrust::raw_pointer_cast(d_x1.data()), thrust::raw_pointer_cast(d_x2.data()), N);
    //gpuErrchk(cudaPeekAtLastError());
    //gpuErrchk(cudaDeviceSynchronize());
    //printf("Timing AoSvsSoA_v2 = %f\n", timerGPU.GetCounter());

    timerGPU.StartCounter();
    AoSvsSoA_v3 << <iDivUp(N, BLOCKSIZE), BLOCKSIZE >> >(cell, N);
    gpuErrchk(cudaPeekAtLastError());
    gpuErrchk(cudaDeviceSynchronize());
    printf("Timing AoSvsSoA_v3 = %f\n", timerGPU.GetCounter());

    h_cells = d_cells;

    h_x1 = d_x1;
    h_x2 = d_x2;

    // --- Check results
    for (int k = 0; k < N; k++) {
        if (h_x1[k] != k + 11) {
            printf("h_x1[%i] not equal to %i\n", h_x1[k], k + 11);
            break;
        }
        if (h_x2[k] != k + 12) {
            printf("h_x2[%i] not equal to %i\n", h_x2[k], k + 12);
            break;
        }
        if (h_cells[k].x1 != k + 11) {
            printf("h_cells[%i].x1 not equal to %i\n", h_cells[k].x1, k + 11);
            break;
        }
        if (h_cells[k].x2 != k + 12) {
            printf("h_cells[%i].x2 not equal to %i\n", h_cells[k].x2, k + 12);
            break;
        }
    }

}

Answer 3

SoA对SIMD处理有很好的效果。出于几个原因，但基本上在寄存器中加载4个连续浮点数更有效。有类似的东西：

 float v [4] = {0};
 __m128 reg = _mm_load_ps( v );

比使用：

 struct vec { float x; float, y; ....} ;
 vec v = {0, 0, 0, 0};

并通过访问所有成员来创建__m128数据：

 __m128 reg = _mm_set_ps(v.x, ....);

如果您的数组是16字节对齐的数据加载/存储更快，而某些操作可以直接在内存中执行。

数组结构与CUDA中的结构数组

3 个答案: