数组的POD结构答案

【问题标题】：POD structure of array数组的POD结构
【发布时间】：2015-11-06 15:45:41
【问题描述】：

我正在尝试用 c 编程围绕 SOA [数组结构]。

我有一些简单的数学函数，我编写了我认为相当不错的标量实现。

这里是一个简单的向量3数据结构

struct vector3_scalar {
    float p[3];
};

以及我编写的一个典型函数，用于添加其中两个向量 3 数据结构。

struct vector3_scalar* vec3_add(struct vector3_scalar* out,
                                const struct vector3_scalar* a,
                                const struct vector3_scalar* b) {
    out->p[0] = a->p[0] + b->p[0];
    out->p[1] = a->p[1] + b->p[1];
    out->p[2] = a->p[2] + b->p[2];

    return out;
}

我知道这个简单的数据结构没有正确填充，但对于标量，我只是想在开始实现其他功能之前先得到一些有效的东西。

现在我的问题是，“无填充问题”结构是设置数据结构的好方法吗？

这些呢？

struct vector3_scalar {
    float p[3];
};


struct vector3_scalar {
    float px;
    float py;
    float pz;
};

或任何其他我可以布置数据的方式。我个人不介意翻转数据结构，因为一旦编写和优化了这个数学的用户不应该把它弄得这么低，只需要更高级的函数就可以了；

vec3 *a = vec3_create(0, 1, 0);
vec3 *b = vec3_create(1, 0, 0);
vec3 *c = vec3_zero(void);

vec3* vec3_add(vec3* out, const vec3* in_a, const vec3* in_b);

c = vec3_add(c, a, b); // c == 1, 1, 0

以便您可以内联或单独使用该函数。

vec3 *d = vec3_create(10, 10, 10);
vec3 *e = vec3_create(1, 1, 1);
vec3 *f = vec3_zero();

/* c + d = 11, 11, 10 */  /* c + e = 2, 2, 1 */
vec3_add(f, vec3_add(c, d), vec3_add(c, e));

vec3_free(a);
...
vec3_free(f);

正如您从公共 api 中看到的那样，除了实现者之外，底层结构应该并不重要。

我想使用如下数据布局编写我已经编写的基本标量版本：

struct vector3_scalar {
     float p[3];
}

但我愿意改变它，因为它可以工作并且看起来足够稳定以符合我的口味。

【问题讨论】：

根据您显示的内容，没有任何其他上下文，如果您使用离散值 px、py、pz 或数组 p[3] 并不重要.我不确定您所说的“填充问题”是什么意思。我认为这两种方法都没有任何问题。你有具体的问题吗？如果不是，那么这个问题很大程度上是基于意见的，或者应该在 codereview.stackexchange.com 区域中。
这些假设的“填充问题”是什么？不要为他们担心；编译器以最佳方式布置事物。对填充感到不安的人要么在设计结构时粗心，要么试图强制文件或有线格式的内存表示与文件或有线格式中的字节完全匹配。没有证据表明这里有问题。在您的两种数据结构中，都没有填充（或者您不太可能有一个引入任何填充的编译器，尽管编译器理论上可以，但实际上不会）。
填充是在处理 SIMD 设备等并行数据操作时，通常为缓存一致性的 16、32、64 或 128 位对齐数据。
我怀疑您误解了 AOS 和 SOA 之间的区别。如果您使用 3 个值的“数组”来表示，例如三维空间中的坐标，您不是在使用数组结构，而是在使用结构数组。
@EOF 我确定我误解了 AOS 和 SOA，这就是问题的根源。我进行了很多搜索并听到了它的提及，但没有太多可靠的文档。你有什么可以参考的吗？

标签： c arrays data-structures parallel-processing structure

【解决方案1】：

这两个都是 AoS 表示，而不是 SoA：

struct vector3_scalar {
    float p[3];
};

struct vector3_scalar {
    float px;
    float py;
    float pz;
};

它们完全相同，对齐和填充相同。例如，在我的身上，sizeof(vector3_scalar) == 12（大小为 3 个浮点数）。

如果我们谈论的是 AoS 向量表示，前者可能有利于与 C API 进行通信，例如，希望接受指向浮点的指针，并且还可以通过允许您循环遍历向量来帮助避免冗余代码组件。

SoA 看起来像这样：

struct vector4
{
     float x[4];
     float y[4];
     float z[4];
};

它将每个字段表示为一个单独的数组，对于 SIMD，它的大小通常是 4 的倍数。

在这种情况下，sizeof(vector4) == 48/4 == 12。由于vector3_scalar 没有填充，我们在这里没有得到任何内存节省的好处。尽管如此，SoA rep 更有利于希望使用 128 位寄存器并受益于对齐内存的 SSE。在这种情况下，我们必须在vector3_scalar 中引入第四个组件，以便能够直接将其加载到 XMM 寄存器中，从而使单个向量占用 16 个字节而不是 12 个字节。此外，根据您的操作，一个AoS 代表可能需要更多的水平/随机类型操作，而 SIMD 并不总是那么快，而 SoA 代表可以一次非常简单地将操作向量化一个组件类型。

但是让我们举一个这样的例子：

struct Person
{
    int y;
    char x;
};

在这种情况下，我的 sizeof(Person) == 8 意味着添加了 3 个字节的填充用于对齐。如果我们使用 SoA 代表：

struct Persons
{
    int y[4];
    char x[4];
};

...sizeof(Persons) == 20。 20 / 4 == 5。所以现在我们每个人有 5 个字节而不是每个人 8 个字节，同时每个字段仍然正确对齐。

从性能的角度来看这是否有益，而不仅仅是从节省内存的角度来看，这在很大程度上取决于哪些字段是热/冷、人数等。您也可以使用 AoSoA：

struct Persons
{
    struct Person4
    {
        int y[4];
        char x[4];
    };
    Person4 persons_x4[n/4];
};

这往往会很好地平衡事情，因为它不会随着n 越来越大而线性降低同一个人的字段之间的空间局部性。

【讨论】：

这是我在这个问题上看到的最好的答案。我去了英特尔论坛以获得更多帮助，但这得到了很好的解释。我想从图形编程中做到这一点，核心低级的东西，一旦它全部设置好就没有人应该搞砸了。目前，虽然我正在使用所有这些数据结构的标量版本，并将继续了解更多关于这方面的知识，以便能够为核心数学运算编写高效的 SSE/NEON 代码。
@user1610950 很多困难的部分只是从设计的角度来看。 SoA 可以非常快，但它们使用起来很尴尬——通常生产力成为与效率一样重要的问题。所以很多挑战可能只是构建一个高级界面，让人们可以使用标量逻辑，例如，当代码对性能不是那么关键时......当他们想要最大速度时选择使用那些 SIMD 例程。

【解决方案2】：

为什么不两者兼而有之？

#include <stdio.h>

struct {
    union {
        float as_arr[3];
        struct {
            float px;
            float py;
            float pz;
        };
    };
} my_point;

int main (void)
{
    my_point.as_arr[1] = .5;
    printf ("%f\n", my_point.py);

    return 0;
}

【讨论】：

【解决方案3】：

您似乎很难理解填充实际上是什么。这只是编译器自动完成的优化。

由于某些硬件/架构原因，一次从内存中获取多个字节。比方说 4，这在当今的架构中很常见。此外，您无法获取任何 4 个连续字节的表单内存。第一个字节的地址必须能被4整除。

现在，假设以下结构：

struct x {
   char a;
   int b;
};

假设我们有一个地址为 100 的 x 实例。因此，在地址 100 的字节中，您将存储 a，并且每当您对 a 进行操作时，您都会获取字节 100、101、102、103。

现在让我们来看看 b 会发生什么。如果 b 将在 a 之后立即开始（即在地址 101 处），则需要 2 次提取。首先，获取字节 100、101、102、103，然后获取 104、105、106、107，然后进行一些计算以获取存储在字节 101-104 上的整数。为了避免这种情况，编译器将在 a 之后插入 3 个字节的填充，这将使您的结构占用 8 个字节，而不是您期望的 5 个字节。但请注意，这只是一种性能优化（基本上是用内存空间换取执行时间），除非你有很多实例或做一些非常高级的事情，否则对你来说没有关系。

此外，就您而言，从内存的角度来看，结构的声明是等效的。

【讨论】：