c - malloc 一次，然后在结构数组上分配内存

Question

我有一个具有以下内存布局的结构:

uint32_t  
variable length array of type uint16_t
variable length array of type uint16_t

由于数组的可变长度，我有指向这些数组的指针，有效地:

struct struct1 {
  uint32_t n;
  uint16_t *array1;
  uint16_t *array2;
};
typedef struct struct1 struct1;

现在，当分配这些结构时，我看到两个选项:

A) malloc 结构本身，然后分别为数组分配空间，并将结构中的指针设置为指向正确的内存位置:

uint32_t n1 = 10;
uint32_t n2 = 20;

struct1 *s1 = malloc(sizeof(struct1));
uint16 *array1 = malloc(sizeof(uint16) * n1));
uint16 *array2 = malloc(sizeof(uint16) * n2));
s1->n = n1;
s1->array1 = array1;
s1->array2 = array2;

B) malloc 内存用于组合所有内容，然后将内存“分配”到结构上:

struct1 *s1 = malloc(sizeof(struct1) + (n1 + n2) * sizeof(uint16_t));
s1->n = n1;
s1->array1 = s1 + sizeof(struct1);
s1->array2 = s1 + sizeof(struct1) + n1 * sizeof(uint16_t);

请注意，array1 和 array2 不超过几 KB，通常不需要很多 struct1。但是，缓存效率是一个问题，因为数字数据处理是使用此结构完成的。

1. 方法 B) 是否可行，如果可行的话，在内存局部性方面比方法 A 更好(更快)？
2. 我对 C 不是很熟悉，有没有更好的方法来做 B(或 A)，即。使用 memcpy 或 realloc 或其他东西？
3. 在这种情况下还有什么需要注意的吗？

请注意，现在我在 Linux 上使用 gcc(C89？)，但如果需要可以使用 C99/C11。提前致谢。

编辑:进一步澄清:数组的大小在创建后永远不会改变。多个 struct1 不会总是一次分配，而是在程序运行时偶尔分配。

Answer 1

我认为您的选项 A 更简洁，并且会以更明智的方式扩展。想象一下当其中一个结构中的数组变大时必须realloc 空间:在选项 A 中，您可以 realloc 该内存，因为它在逻辑上没有附加到任何其他内容。在选项 B 中，您需要添加额外的逻辑以确保您不会破坏其他数组。

我也认为(即使在 C89 中，但我可能是错的)这没有错:

struct1 *s1 = malloc(sizeof(struct1));
s1->array1 = malloc(sizeof(uint16) * n1));
s1->array2 = malloc(sizeof(uint16) * n2));
s1->n = n1;

上面去掉了中间人数组。我认为它更简洁，因为您会立即看到您正在为结构中的指针分配空间。

我之前对二维数组使用过你的选项 B，我只是分配一个空间并在我的代码中使用逻辑规则将其用作二维空间。当我希望它是一个矩形 2D 空间时，这很有用，所以当我增加它时，我总是增加每一行或每一列。换句话说，我从不想拥有异构的数组大小。

更新:“数组的大小永远不会改变”

因为您阐明了永远不需要重新分配您的结构/数组，所以我认为选项 B 没那么糟糕。对于此应用程序，它似乎仍然是比选项 A 更糟糕的解决方案，以下是我这样认为的原因:

• malloc 经过优化，与单独分配空间相比，分配单个空间不会有太多优化。
• 其他工程师查看并立即理解您的代码的能力将会降低。需要明确的是，任何称职的软件工程师都应该能够查看选项 B 并弄清楚代码的编写者在做什么，但这很可能会浪费工程师的思维周期并可能导致初级工程师误解代码并创建一个错误。

因此，如果您对代码进行彻底的注释，并且您的应用程序绝对需要您尽可能优化所有内容，而代价是干净且逻辑上合理的代码(其中内存空间和数据结构以类似的方式在逻辑上分开)，并且您知道这种优化比一个好的编译器(如 Clang)可以做的更好，那么选项 B 可能是更好的选择。

更新:测试

本着 self 批评的精神，我想看看我是否可以评估差异。所以我写了两个程序(一个用于选项 A，一个用于选项 B)并在关闭优化的情况下编译它们。我使用 FreeBSD 虚拟机来获得尽可能干净的环境，并且我使用了 gcc。

以下是我用来测试这两种方法的程序:

选项A.c:

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

#define NSIZE   100000
#define NTESTS  10000000

struct test_struct {
    int n;
    int *array1;
    int *array2;
};

void freeA(struct test_struct *input) {
    free(input->array1);
    free(input->array2);
    free(input);
    return;
}

void optionA() {
    struct test_struct *s1 = malloc(sizeof(*s1));
    s1->array1 = malloc(sizeof(*(s1->array1)) * NSIZE);
    s1->array2 = malloc(sizeof(*(s1->array1)) * NSIZE);
    s1->n = NSIZE;
    freeA(s1);
    s1 = 0;
    return;
}

int main() {
    clock_t beginA = clock();
    int i;
    for (i=0; i<NTESTS; i++) {
        optionA();
    }
    clock_t endA = clock();
    int time_spent_A = (endA - beginA);
    printf("Time spent for option A: %d\n", time_spent_A);
    return 0;
}

选项B.c:

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

#define NSIZE   100000
#define NTESTS  10000000

struct test_struct {
    int n;
    int *array1;
    int *array2;
};

void freeB(struct test_struct *input) {
    free(input);
    return;
}

void optionB() {
    struct test_struct *s1 = malloc(sizeof(*s1) + 2*NSIZE*sizeof(*(s1->array1)));
    s1->array1 = s1 + sizeof(*s1);
    s1->array2 = s1 + sizeof(*s1) + NSIZE*sizeof(*(s1->array1));
    s1->n = NSIZE;
    freeB(s1);
    s1 = 0;
    return;
}

int main() {
    clock_t beginB = clock();
    int i;
    for (i=0; i<NTESTS; i++) {
        optionB();
    }
    clock_t endB = clock();
    int time_spent_B = (endB - beginB);
    printf("Time spent for option B: %d\n", time_spent_B);
    return 0;
}

这些测试的结果以时钟形式给出(更多信息请参见 clock(3))。

 Series | Option A | Option B
------------------------------
 1      | 332      | 158
------------------------------
 2      | 334      | 155
------------------------------
 3      | 334      | 156
------------------------------
 4      | 333      | 154
------------------------------
 5      | 339      | 156
------------------------------
 6      | 334      | 155
------------------------------
 avg    | 336.0    | 155.7
------------------------------

请注意，这些速度仍然非常快，并且在数百万次测试中转化为毫秒。我还发现 Clang (cc) 在优化方面优于 gcc。在我的机器上，即使在编写了一个将数据写入数组的方法(以确保它们不会被优化到不存在)之后，我在使用 cc 进行编译时也没有发现这两种方法之间的区别。