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

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

1) Достаточно хорошо для точного вопроса, заданного решением Джонатана Леффлера, за исключением того, что для округления до 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;

В:

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;

В:

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

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

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

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

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-разрядная) Solaris 10, похоже, что базовое выравнивание для результата из malloc() является кратным 32 байтам.
]

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

3) Используйте то, что предлагает ваша платформа: posix_memalign для POSIX, _aligned_malloc в Windows.

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

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

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

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

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

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

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

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

Было бы неплохо ошибиться в этом заявлении.

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

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

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

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

В приведенном ниже примере в большинстве систем значение 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)

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

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

Мы все время делаем для Accelerate.framework, сильно векторизованной библиотеки OS X/iOS, где мы должны постоянно обращать внимание на выравнивание. Существует несколько вариантов, один или два из которых я не видел выше.

Самый быстрый способ для небольшого массива, подобного этому, просто вставить его в стек. С GCC/clang:

 void my_func( void )
 {
     uint8_t array[1024] __attribute__ ((aligned(16)));
     ...
 }

Нет бесплатной(). Обычно это две инструкции: вычесть 1024 из указателя стека, а затем указатель стека с -ограничением. Предположительно, запросчику нужны данные о куче, потому что его продолжительность жизни в массиве превысила стек, или рекурсия работает, или пространство стека имеет серьезную премию.

В OS X/iOS все вызовы malloc/calloc/etc. всегда выравниваются по 16 байт. Если вам понадобилось 32 байт, выровненных для AVX, например, вы можете использовать posix_memalign:

void *buf = NULL;
int err = posix_memalign( &buf, 32 /*alignment*/, 1024 /*size*/);
if( err )
   RunInCirclesWaivingArmsWildly();
...
free(buf);

Некоторые люди упомянули интерфейс С++, который работает аналогично.

Не следует забывать, что страницы выровнены с большими степенями по два, поэтому выравниваемые по страницам буферы также выравниваются по 16 байт. Таким образом, mmap() и valloc() и другие аналогичные интерфейсы также являются опциями. mmap() имеет то преимущество, что буфер может быть выделен при инициализации чем-то ненулевым, если хотите. Поскольку они имеют размер с выравниванием по страницам, вы не получите минимальное выделение из них, и при первом прикосновении к нему, вероятно, будет применена ошибка VM.

Cheesy: Включите охранник malloc или аналогичный. Буферы размером n * 16 байтов, такие как этот, будут выравниваться по n * 16 байт, потому что VM используется для захвата перерасхода, а его границы находятся на границах страницы.

Некоторые функции Accelerate.framework берут временный буфер, предоставленный пользователем, для использования в качестве пространства скреста. Здесь мы должны предположить, что буфер, переданный нам, дико смещен, и пользователь активно пытается избавить нашу жизнь от злости. (Наши тестовые примеры прикрепляют страницу защиты до и после буфера temp, чтобы подчеркнуть злобу.) Здесь мы возвращаем минимальный размер, который нам нужен, чтобы гарантировать, что сегмент с 16 байтами выровнен где-то в нем, а затем вручную выровнять буфер после этого. Этот размер желательно_размер + выравнивание - 1. Итак, в этом случае это 1024 + 16 - 1 = 1039 байт. Затем выровняйте так:

#include <stdint.h>
void My_func( uint8_t *tempBuf, ... )
{
    uint8_t *alignedBuf = (uint8_t*) 
                          (((uintptr_t) tempBuf + ((uintptr_t)alignment-1)) 
                                        & -((uintptr_t) alignment));
    ...
}

Добавление выравнивания-1 перемещает указатель мимо первого выровненного адреса, а затем ANDing с -ограничением (например, 0xfff... ff0 для выравнивания = 16) возвращает его к выровненному адресу.

Как описано другими сообщениями, в других операционных системах без гарантий на 16 байт вы можете вызывать malloc с большим размером, позже отложить указатель на free(), а затем выровнять, как описано выше, и использовать выровненный указатель, как описано для нашего временного буфера.

Что касается aligned_memset, это довольно глупо. Вам нужно всего лишь занять до 15 байт, чтобы достичь выровненного адреса, а затем продолжить с выровненными хранилищами после этого с некоторым возможным кодом очистки в конце. Вы можете даже выполнять очистку битов в векторном коде, либо в виде неустановленных магазинов, которые перекрывают выровненную область (обеспечивая длину, по крайней мере, длину вектора), либо используя что-то вроде movmaskdqu. Кто-то просто ленится. Тем не менее, вероятно, разумный вопрос интервью, если интервьюер хочет узнать, удобны ли вы с stdint.h, побитовыми операторами и основными принципами памяти, поэтому надуманный пример можно простить.

Я удивлен, что никто не проголосовал Shao ответить, что, как я понимаю, это невозможно сделать то, что задано в стандарте C99, поскольку формальное преобразование указателя в интегральный тип является undefined. (Помимо стандарта, допускающего преобразование uintptr_t ↔ void*, но стандарт, похоже, не позволяет делать какие-либо манипуляции с значением uintptr_t и затем преобразовывать его обратно.)

Первое, что появилось в моей голове при чтении этого вопроса, - это определить выровненную структуру, создать экземпляр, а затем указать на нее.

Есть ли фундаментальная причина, по которой я отсутствую, поскольку никто не предлагал это?

Как sidenote, так как я использовал массив char (предполагая, что система char имеет 8 бит (то есть 1 байт)), я не вижу необходимости в атрибуте ((упакован)) обязательно (исправьте меня, если я ошибаюсь), но я все равно вложил его.

Это работает на двух системах, в которых я это пробовал, но возможно, что есть оптимизация компилятора, которую я не знаю, чтобы дать мне ложные срабатывания по сравнению с эффективностью кода. Я использовал gcc 4.9.2 на OSX и gcc 5.2.1 на Ubuntu.

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

int main ()
{

   void *mem;

   void *ptr;

   // answer a) here
   struct __attribute__((packed)) s_CozyMem {
       char acSpace[16];
   };

   mem = malloc(sizeof(struct s_CozyMem));
   ptr = mem;

   // memset_16aligned(ptr, 0, 1024);

   // Check if it aligned
   if(((unsigned long)ptr & 15) == 0) printf("Aligned to 16 bytes.\n");
   else printf("Rubbish.\n");

   // answer b) here
   free(mem);

   return 1;
}

использование memalign, Aligned-Memory-Blocks может быть хорошим решением проблемы.

Спецификация MacOS X:

• Все указатели, выделенные malloc, выравниваются по 16 байт.

• Поддерживается C11, поэтому вы можете просто вызвать aligned_malloc (16, размер).

• MacOS X выбирает код, оптимизированный для отдельных процессоров во время загрузки для memset, memcpy и memmove, и этот код использует трюки, о которых вы никогда не слышали, чтобы сделать их быстрыми. 99% вероятность того, что memset работает быстрее, чем любая рукописная memset16, которая делает весь вопрос бессмысленным.

Если вам требуется 100% портативное решение, перед C11 его нет. Потому что нет переносного способа проверки выравнивания указателя. Если он не должен быть на 100% переносимым, вы можете использовать

char* p = malloc (size + 15);
p += (- (unsigned int) p) % 16;

Это предполагает, что выравнивание указателя хранится в младших битах при преобразовании указателя в unsigned int. Преобразование в unsigned int теряет информацию и определяется реализацией, но это не имеет значения, потому что мы не преобразуем результат обратно в указатель.

Ужасная часть, конечно же, заключается в том, что исходный указатель должен быть где-то сохранен для вызова free() с ним. Так что в целом я бы действительно сомневался в мудрости этого дизайна.

Для решения я использовал концепцию заполнения, которая выравнивает память и не тратит   память одного байта.

Если есть ограничения, вы не можете тратить один байт. Все указатели, выделенные malloc, выравниваются по 16 байт.

C11 поддерживается, поэтому вы можете просто вызвать aligned_malloc (16, размер).

void *mem = malloc(1024+16);
void *ptr = ((char *)mem+16) & ~ 0x0F;
memset_16aligned(ptr, 0, 1024);
free(mem);

Если есть ограничения, которые вы не можете тратить на один байт, то это решение работает: Примечание. Существует случай, когда это может выполняться бесконечно: D

   void *mem;  
   void *ptr;
try:
   mem =  malloc(1024);  
   if (mem % 16 != 0) {  
       free(mem);  
       goto try;
   }  
   ptr = mem;  
   memset_16aligned(ptr, 0, 1024);

Вы также можете добавить 16 байт, а затем вывести исходный ptr на 16 бит, выровненный, добавив (16-mod), как показано ниже указателя:

main(){
void *mem1 = malloc(1024+16);
void *mem = ((char*)mem1)+1; // force misalign ( my computer always aligns)
printf ( " ptr = %p \n ", mem );
void *ptr = ((long)mem+16) & ~ 0x0F;
printf ( " aligned ptr = %p \n ", ptr );

printf (" ptr after adding diff mod %p (same as above ) ", (long)mem1 + (16 -((long)mem1%16)) );


free(mem1);
}

Просто используйте memalign? http://linux.die.net/man/3/memalign

long add;   
mem = (void*)malloc(1024 +15);
add = (long)mem;
add = add - (add % 16);//align to 16 byte boundary
ptr = (whatever*)(add);