Как выровнять стек по границе 32 байта в GCC?

Я изучал эту проблему, подал отчет об ошибке GCC и обнаружил, что это проблема, связанная с MinGW64. См. ошибка GCC №49001. Судя по всему, GCC не поддерживает выравнивание стека по 32 байта в Windows. Это эффективно предотвращает использование 256-битных инструкций AVX.

Я исследовал несколько способов решения этой проблемы. Самое простое и прямолинейное решение — заменить выровненный доступ к памяти VMOVAPS/PD/DQA невыровненными альтернативами VMOVUPS и т. д. Итак, прошлой ночью я изучил Python (кстати, очень хороший инструмент) и выполнил следующий скрипт, который выполняет эту работу с входной ассемблерный файл, созданный GCC:

import re
import fileinput
import sys

# fix aligned stack access
# replace aligned vmov* by unaligned vmov* with 32-byte aligned operands 
# see Intel's AVX programming guide, page 39
vmova = re.compile(r"\s*?vmov(\w+).*?((\(%r.*?%ymm)|(%ymm.*?\(%r))")
aligndict = {"aps" : "ups", "apd" : "upd", "dqa" : "dqu"};
for line in fileinput.FileInput(sys.argv[1:],inplace=1):
    m = vmova.match(line)
    if m and m.group(1) in aligndict:
        s = m.group(1)
        print line.replace("vmov"+s, "vmov"+aligndict[s]),
    else:
        print line,

Этот подход довольно безопасен и надежен. Хотя в редких случаях я наблюдал снижение производительности. Когда стек не выровнен, доступ к памяти пересекает границу строки кэша. К счастью, в большинстве случаев код работает так же быстро, как и выровненный доступ. Моя рекомендация: встроенные функции в критических циклах!

Я также попытался исправить распределение стека в прологе каждой функции, используя другой скрипт Python, стараясь всегда выравнивать его по 32-байтовой границе. Кажется, это работает для одного кода, но не для другого. Я должен полагаться на добрую волю GCC, что он будет выделять выровненные локальные переменные (относительно указателя стека), что он обычно и делает. Это не всегда так, особенно при серьезном сбросе регистров из-за необходимости сохранения всего регистра ymm перед вызовом функции. (Все регистры ymm сохраняют вызов). Скрипт могу выложить, если интересно.

Лучшим решением будет исправить сборку GCC MinGW64. К сожалению, я ничего не знаю о его внутренней работе, я только начал использовать его на прошлой неделе.

Вы можете получить желаемый эффект,

1. Объявление ваших переменных не как переменных, а как полей в структуре
2. Объявление массива, который больше структуры на соответствующее количество отступов
3. Выполнение арифметики указателя/адреса для поиска 32-байтового выровненного адреса внутри массива
4. Приведение этого адреса к указателю на вашу структуру
5. Наконец, используя элементы данных вашей структуры

Вы можете использовать ту же технику, когда malloc() не выравнивает данные в куче должным образом.

E.g.

void foo() {
    struct I_wish_these_were_32B_aligned {
          vec32B foo;
          char bar[32];
    }; // not - no variable definition, just the struct declaration.
    unsigned char a[sizeof(I_wish_these_were_32B_aligned) + 32)];
    unsigned char* a_aligned_to_32B = align_to_32B(a);
    I_wish_these_were_32B_aligned* s = (I_wish_these_were_32B_aligned)a_aligned_to_32B;
    s->foo = ...
}

где

unsigned char* align_to_32B(unsiged char* a) {
     uint64_t u = (unit64_t)a;
     mask_aligned32B = (1 << 5) - 1;
     if (u & mask_aligned32B == 0) return (unsigned char*)u;
     return (unsigned char*)((u|mask_aligned_32B) + 1);
}

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

1. Использование статических переменных (см. эту проблему ). Учитывая тот факт, что они не хранятся в стеке, вы можете принудительно выровнять их, используя __attribute__((align(32))) в своем объявлении. Например: static __m256i r __attribute__((aligned(32))).

2. Встраивание функций/методов, получающих/возвращающих данные AVX. Вы можете заставить GCC встроить вашу функцию/метод, добавив inline и __attribute__((always_inline)) к прототипу/объявлению функции. Встраивание ваших функций увеличивает размер вашей программы, но также не позволяет функции использовать стек (и, следовательно, позволяет избежать проблемы с выравниванием стека). Пример: inline __m256i myAvxFunction(void) __attribute__((always_inline));.