Comment aligner la pile à 32 limites d'octets dans GCC?

J'ai exploré la question, a déposé un rapport de bogue GCC et a découvert qu'il s'agit d'un problème connexe MINGW64. Voir Bug de GCC # 49001 . Apparemment, GCC ne prend pas en charge l'alignement de la pile de 32 octets sur Windows. Cela empêche efficacement l'utilisation d'instructions AVX 256 bits.

J'ai enquêté sur la manière de faire face à ce problème. La solution la plus simple et la plus blunte est de remplacer les accès à la mémoire alignée VMOVAPS / PD / DQA par des alternatives non alignées VMOVUPUPS, etc. Alors j'ai appris Python la nuit dernière (très bel outil, en passant) et retiré le script suivant qui fait le travail avec un Fichier d'assembleur d'entrée Produit par GCC: P>

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,

Vous pouvez obtenir l'effet que vous voulez par

1. Déclarant vos variables pas comme variables, mais comme champs dans une structure
2. Déclarant un tableau plus grand que la structure par une quantité appropriée de remplissage
3. faire du pointeur / adresse arithmétique pour trouver une adresse alignée de 32 octets à la côte de la matrice
4. casting qui adresse à un pointeur à votre structure
5. Enfin en utilisant les membres de données de votre structure

   Vous pouvez utiliser la même technique lorsque MALLOC () ne correspond pas de substance sur le tas de manière appropriée.

   par exemple xxx

   où xxx

Je viens de courir dans le même problème d'avoir des défauts de segmentation lors de l'utilisation d'AVX à l'intérieur de mes fonctions. Et c'était également dû au désalignement de la pile. Compte tenu du fait qu'il s'agit d'un problème de compilateur (et des options pouvant aider ne sont pas disponibles dans Windows), j'ai travaillé autour de l'utilisation de la pile par:

1. à l'aide de variables statiques (voir cette problème ). Compte tenu du fait qu'ils ne sont pas stockés dans la pile, vous pouvez forcer leur alignement en utilisant __ attribut __ ((alignement (32))) dans votre déclaration. Par exemple: statique __m256i r __attribute __ ((aligné (32))) .

2. Inlinge des fonctions / méthodes recevant / renvoyer les données AVX . Vous pouvez forcer GCC à la configuration de votre fonction / méthode en ajoutant inline et __ ((toujours_inline)) à votre prototype / déclaration de fonction. L'amélioration de vos fonctions augmente la taille de votre programme, mais elles empêchent également la fonction d'utiliser la pile (et donc, évite la question de la pile-alignement). Exemple: inline __m256i myavxfonction (vide) __attribute __ ((toujours_inline)); .

   Sachez que l'utilisation de variables statiques n'est pas une sécurité du thread, comme indiqué dans la référence. Si vous écrivez une application multi-threadée, vous devrez peut-être ajouter une certaine protection pour vos chemins critiques.