Как выделить выровненную память только с использованием стандартной библиотеки?

Возможно, они были бы удовлетворены знанием memalign? И поскольку Jonathan Leffler указывает, существует две более новых предпочтительных функции для знания о.

ой, флорин избил меня к нему. Однако, если Вы читаете страницу справочника, я связался с, Вы, скорее всего, поймете пример, предоставленный более ранним плакатом.

Вот альтернативный подход к вокруг' части. Не наиболее блестяще кодированное решение, но это сделало задание, и этот тип синтаксиса немного легче помнить (плюс, работал бы на значения выравнивания, которые не являются питанием 2). Эти uintptr_t бросок был необходим для успокоения компилятора; адресная арифметика с указателями не очень любит разделение или умножение.

void *mem = malloc(1024 + 15);
void *ptr = (void*) ((uintptr_t) mem + 15) / 16 * 16;
memset_16aligned(ptr, 0, 1024);
free(mem);

Вы могли также попробовать posix_memalign() (на платформах POSIX, конечно).

Три немного отличающихся ответа, зависящие, как Вы смотрите на вопрос:

1) Достаточно хороший для точного вопроса, который задают, решение Jonathan Leffler, за исключением того, что окружить к 16 выровненному, Вам только нужны 15 дополнительных байтов, не 16.

А:

/* allocate a buffer with room to add 0-15 bytes to ensure 16-alignment */
void *mem = malloc(1024+15);
ASSERT(mem); // some kind of error-handling code
/* round up to multiple of 16: add 15 and then round down by masking */
void *ptr = ((char*)mem+15) & ~ (size_t)0x0F;

B:

free(mem);

2) Для более универсальной функции выделения памяти, вызывающая сторона не хочет должной быть отслеживать два указателя (один для использования и один для свободного). Таким образом, Вы храните указатель на 'реальный' буфер ниже выровненного буфера.

А:

void *mem = malloc(1024+15+sizeof(void*));
if (!mem) return mem;
void *ptr = ((char*)mem+sizeof(void*)+15) & ~ (size_t)0x0F;
((void**)ptr)[-1] = mem;
return ptr;

B:

if (ptr) free(((void**)ptr)[-1]);

Примечание, что, в отличие от этого (1), где только 15 байтов были добавлены к мадам, этот код мог на самом деле , уменьшает выравнивание, если Ваша реализация, оказывается, гарантирует 32-байтовое выравнивание от malloc (вряд ли, но в теории реализация C могла иметь выровненный тип 32 байтов). Это не имеет значения, ли все, что Вы делаете, назвать memset_16aligned, но если Вы используете память для структуры тогда, это могло бы иметь значение.

я не уверен пренебрежительный, что хорошая фиксация для этого (кроме предупредить пользователя, что возвращенный буфер не обязательно подходит для произвольных структур), так как нет никакого способа определить программно, какова определенная для реализации гарантия выравнивания. Я предполагаю запуск, Вы могли выделить два или больше 1-байтовых буфера и предположить, что худшее выравнивание, которое Вы видите, является гарантируемым выравниванием. Если Вы неправы, Вы тратите впустую память. Любой с лучшей идеей, скажите так...

[ Добавленный : 'стандартный' прием должен создать объединение, 'вероятно, чтобы быть максимально выровненным типы' для определения необходимого выравнивания. Максимально выровненные типы, вероятно, будут (в C99) 'long long', 'long double', 'void *', или' void (*)(void)'; если Вы включаете <stdint.h>, Вы могли бы, по-видимому, использовать' intmax_t' вместо [1 111] (и, на Питании 6 (AIX), машины, intmax_t дадут Вам 128-разрядный целый тип). Требования выравнивания для того объединения могут быть определены путем встраивания его в структуру с единственным символом, сопровождаемым объединением:

struct alignment
{
    char     c;
    union
    {
        intmax_t      imax;
        long double   ldbl;
        void         *vptr;
        void        (*fptr)(void);
    }        u;
} align_data;
size_t align = (char *)&align_data.u.imax - &align_data.c;

Вы тогда использовали бы большее из требуемого выравнивания (в примере, 16) и align значение, вычисленное выше.

На (64-разрядном) Солярисе 10, кажется, что основное выравнивание для результата malloc() является кратным 32 байтам.
]

На практике, выровненные средства выделения часто берут параметр для выравнивания, а не этого быть предрасположенное. Таким образом, пользователь передаст в размере структуры, о которой они заботятся (или наименьшее количество питания 2 больших, чем или равный этому), и все будут хорошо.

3) Использование, что обеспечивает Ваша платформа: posix_memalign для POSIX, _aligned_malloc в Windows.

4) при использовании C11, тогда самое чистое - портативный и краткий - опция состоит в том, чтобы использовать стандартную библиотечную функцию aligned_alloc , которая была представлена в этой версии спецификации языка.

size =1024;
alignment = 16;
aligned_size = size +(alignment -(size %  alignment));
mem = malloc(aligned_size);
memset_16aligned(mem, 0, 1024);
free(mem);

Hope этот - самая простая реализация, сообщите мне свои комментарии.

На фронте заполнения 16 и 15 байтов фактическое число, которое вам нужно добавить, чтобы получить выравнивание N, составляет max (0, NM) , где M - естественное выравнивание распределителя памяти (и оба являются степенями 2).

Поскольку минимальное выравнивание памяти любого распределителя составляет 1 байт, 15 = max (0,16-1) - консервативный ответ. Однако, если вы знаете, что ваш распределитель памяти будет выдавать вам 32-битные адреса, выровненные по int (что довольно часто), вы могли бы использовать 12 в качестве контактной площадки.

Это не важно для данного примера, но может быть важно для встроенной системы с 12 КБ ОЗУ, где учитывается каждый сохраненный int.

Лучший способ реализовать его, если вы действительно собираетесь сохранить каждый возможный байт, - это использовать макрос, чтобы вы могли передать ему свою собственную память выравнивание. Еще раз, это, вероятно, полезно только для встроенных систем, где вам нужно сохранить каждый байт.

В приведенном ниже примере для большинства систем значение 1 вполне подходит для MEMORY_ALLOCATOR_NATIVE_ALIGNMENT , однако для нашей теоретической встроенной системы с 32-битное выравнивание, следующее может сэкономить крошечный бит драгоценной памяти:

#define MEMORY_ALLOCATOR_NATIVE_ALIGNMENT    4
#define ALIGN_PAD2(N,M) (((N)>(M)) ? ((N)-(M)) : 0)
#define ALIGN_PAD(N) ALIGN_PAD2((N), MEMORY_ALLOCATOR_NATIVE_ALIGNMENT)

К сожалению, в C99 довольно сложно гарантировать любое выравнивание таким образом, чтобы его можно было переносить в любую реализацию C, соответствующую C99. Почему? Поскольку указатель не обязательно является «байтовым адресом», это можно представить с помощью плоской модели памяти. Также не гарантируется представление uintptr_t , которое в любом случае является необязательным типом.

Возможно, мы знаем о некоторых реализациях, которые используют представление для void * (и по определению также char * ), который является простым байтовым адресом, но для C99 он непрозрачен. нам, программистам. Реализация может представлять указатель с помощью набора { сегмента , смещения }, где смещение могло иметь неизвестное выравнивание «в действительности». Почему, указатель может даже быть некоторой формой значения поиска в хеш-таблице или даже значением поиска в связанном списке. Он мог кодировать информацию о границах.

В недавнем черновике C1X для стандарта C мы видим ключевое слово _Alignas . Это может немного помочь.

Единственная гарантия, которую дает нам C99, заключается в том, что функции выделения памяти будут возвращать указатель, подходящий для присвоения указателю, указывающему на любой тип объекта. Поскольку мы не можем указать выравнивание объектов, мы не можем реализовать наши собственные функции распределения, отвечающие за выравнивание, четко определенным переносимым способом.

Было бы хорошо ошибиться в этом утверждении.