将单个 malloc 切 block /分割/打包成具有不同类型/对齐方式的多个数组的规范方法？

Question

背景:我有一个 C99 例程，需要临时存储具有不同对齐要求的不同数据类型。目前，我多次调用 posix_memalign，这 a) 引入了大量开销，b) 不能保证我的临时对象具有良好的内存局部性。我无法将临时对象打包到单个结构中，因为大小要求仅在运行时已知。

问题:我想用足够大的尺寸调用malloc(或类似的东西)一次，这样我就可以用需要对齐。在 C99 中是否有规范的方法来完成此任务？

具体示例的可能(但不太可能)答案:假设我想为 char[3]、double[m ] 具有 16 字节对齐，一个 int 和一个具有 16 字节对齐的 float[n] 并且我要求它们按此顺序存储在内存中。请忽略这个顺序是愚蠢的，这个例子是人为的。我的实际用例是一个控制结构，后跟几个混合整数/数字类型的临时数组，对齐方式允许 SSE 操作。

使用来自 How to allocate aligned memory only using the standard library? 的想法一个人可能会这样做:

// Several unnecessary values (e.g. alignment_c) are holdovers
// from the macros generating this logic.

// ell, m, and n are sizes known only at runtime

const size_t    datasize_c  = 3*sizeof(char);
const size_t    alignment_c = __alignof__(char);
const size_t    pad_c       = alignment_c - 1;
const uintptr_t mask_c      = ~(uintptr_t)(alignment_c - 1);

const size_t    datasize_d  = ell*sizeof(double);
const size_t    alignment_d = __alignof__(double) > 16 ? __alignof__(double) : 16;
const size_t    pad_d       = alignment_d - 1;
const uintptr_t mask_d      = ~(uintptr_t)(alignment_d - 1);

const size_t    datasize_i  = m*sizeof(int);
const size_t    alignment_i = __alignof__(int);
const size_t    pad_i       = alignment_i - 1;
const uintptr_t mask_i      = ~(uintptr_t)(alignment_i - 1);

const size_t    datasize_f  = n*sizeof(float);
const size_t    alignment_f = __alignof__(float) > 16 ? __alignof__(float) : 16;
const size_t    pad_f       = alignment_f - 1;
const uintptr_t mask_f      = ~(uintptr_t)(alignment_f - 1);


const size_t p_parcel = (datasize_c + pad_c)
                      + (datasize_d + pad_d)
                      + (datasize_i + pad_i)
                      + (datasize_f + pad_f) ;

void   * const p = malloc(p_parcel) ;
char   *       c = (void *) (((uintptr_t)(p      ) + pad_c & mask_c));
double *       d = (void *) (((uintptr_t)(c + ell) + pad_d & mask_d));
int    *       i = (void *) (((uintptr_t)(d + m  ) + pad_i & mask_i));
float  *       f = (void *) (((uintptr_t)(i + n  ) + pad_f & mask_f));

// check if p is NULL, use (c, d, i, f), then free p

我相信这种可能性在功能上是正确的，但我想知道是否有人有更好、更清洁、更短的方法？

我认为使用 struct hack 的方法不可行，因为我只能使用单个 struct hack 的 malloc 来保证一个数组的对齐。我仍然需要三个 malloc 调用来实现三个独立的结构 hack。

最后，如果有人需要的话，我很乐意提供产生困惑的宏。

Answer 1

struct malloc_wrapper {
    char *storage;
    size_t capacity;
    size_t first_free;
};

初始化:

void init_malloc_wrapper(struct malloc_wrapper *mw, size_t cap) { // or int
    if (!mw) {
        perror("No struct malloc_wrapper passed\n");
        exit(EXIT_FAILURE);
    }
    mw->storage = malloc(cap);
    if (mw->storage == NULL) {
        perror("allocation failed\n");
        exit(EXIT_FAILURE); // or return 0;
    }
    mw->capacity = cap;
    mw->first_free = 0;
    // return 1;
}

void clear_malloc_wrapper(struct malloc_wrapper *mw) {
    if (!mw) {
        return;
    }
    if (mw->storage) {
        free(mw->storage);
    }
    mw->storage = NULL;
    mw->capacity = 0;
    mw->first_free = 0;
}

分配一 block 内存:

// First version assumed that `malloc` returns memory aligned suitable for all requests.
// That's probably true, but just in case, we have to be a bit more cautious.
void *deal_out(struct malloc_wrapper *mw, size_t align, size_t size, size_t nmemb) {
    if (!align || (align & (align-1))) {
        perror("invalid alignment\n");
        exit(EXIT_FAILURE);
    }
    if (!mw) {
       perror("No malloc_wrapper\n");
        exit(EXIT_FAILURE);
    }
    uintptr_t start = ((uintptr_t(mw->storage) + mw->first_free + align-1) & ~(align-1);
    size_t offset = start - (uintptr_t)mw->storage;
    if ((mw->capacity - offset) < size*nmemb) {
        return NULL;   // not enough space
    }
    mw->first_free = offset + size*nmemb;
    return (void *)start;
}

根据偏执狂，可能需要进行更多检查。有了它，您可以根据需要处理适当对齐的 block 。但是，如果您在初始化时没有分配足够的存储空间，则处理进一步的请求会有些复杂。释放是全部或全部。所以这可能不是一个改进。

编辑:为了处理初始容量的问题，可以添加一个已用存储 block 的列表，或者只有指针，或者存储、偏移量和剩余容量。如果超过可用容量的新请求到达，则将当前存储 block 添加到列表中并分配一个新的。如果记住了已用 block 的剩余容量，对于较小的请求，可以遍历旧 block 列表以查看它是否适合其中一个。

deal_out 的第一个版本没有考虑对齐需求大于 malloc 返回对齐的可能性，现在已修复。