Выделить в стеке выровненную память, например _alloca

Увеличьте доступность с помощью _alloca (), затем выровняйте вручную. Нравится:

const int align = 32;
void *p =_alloca(n + align - 1);
__m256d *pm = (__m256d *)((((int_ptr_t)p + align - 1) / align) * align);

При необходимости замените const на #define.

_alloca(), безусловно, не является стандартным или переносимым способом обработки выравнивания в стеке. К счастью, в C ++ 11 мы получили alignas и std::aligned_storage. Ни один из этих способов не заставляет вас класть что-либо в кучу, поэтому они должны работать для вашего варианта использования. Например, чтобы выровнять массив структур по границе 32 байта:

#include <type_traits>

struct bar { int member; /*...*/ };
void fun() {
  std::aligned_storage<sizeof(bar), 32>::type array[16];
  auto bar_array = reinterpret_cast<bar*>(array);
}

Или, если вы просто хотите выровнять одну переменную в стеке по границе:

void bun() {
  alignas(32) bar b;
}

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

В C ++ 11 появился оператор alignof:

Выражение alignof дает требование выравнивания его типа операнда.

Вы можете использовать его следующим образом:

struct s {};
typedef s __attribute__ ((aligned (64))) aligned_s;

std::cout << alignof(aligned_s); // Outputs: 64

Примечание. Если выравнивание вашего типа больше, чем его размер, компилятор не позволит вам объявлять массивы типа массива (см. подробнее здесь):

ошибка: выравнивание элементов массива больше размера элемента

Но, если выравнивание вашего типа меньше его размера, вы можете спокойно выделять массивы:

aligned_s arr[32];
-- OR --
constexpr size_t arr_size = 32;
aligned_s arr[arr_size];

Компиляторы, поддерживающие VLA, также позволят использовать их для нового определенного типа.

«Современный» способ:

Не выделяйте переменную длину для стек.

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

С другой стороны, если вы заранее знаете, каков предел размера распределения - просто заранее выделите такой объем памяти в локальном хранилище потока; или используйте локальный массив фиксированного размера (который будет размещен в стеке).