Question sur l'alignement du pointeur

Question

Je travaille sur une implémentation de pool de mémoire et je suis un peu confus au sujet de l'alignement des pointeurs ...

Supposons que j'ai un pool de mémoire qui distribue des blocs de mémoire de taille fixe, au moment de la création du pool de mémoire, je malloc ((taille) * (nombre de blocs)). Si les objets alloués sont des objets et que la taille provient de la taille de l'opérateur, l'alignement ne devrait pas être un problème, mais si la taille est inégale (il / elle veut 100 blocs d'octets pour quelque raison que ce soit), alors lorsque je divise la partie donnée par malloc Je finirais avec des pointeurs non alignés. Ma question est la suivante: devrais-je toujours aligner les blocs sur certaines limites et si oui lesquels?

Answer 1

X86 fonctionnera sans alignement, mais les performances sont meilleures lorsque les données sont alignées. L’alignement pour le type correspond généralement à sizeof ( type ), avec un maximum de 16 (octets).

J’ai écrit ce programme de test idiot juste pour être sûr (asuming malloc sait ce qu’il fait), et il en renvoie 16 sur ma boîte amd64. Il renvoie 8 lorsqu'il est compilé en mode 32 bits:

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

int main() {
    int i;
    unsigned long used_bits = 0, alignment;

    for (i = 0; i < 1000; ++i) {
        used_bits |= (unsigned long)malloc(1);   /* common sizes */
        used_bits |= (unsigned long)malloc(2);   
        used_bits |= (unsigned long)malloc(4);
        used_bits |= (unsigned long)malloc(8);
        used_bits |= (unsigned long)malloc(16);
        used_bits |= (unsigned long)malloc(437); /* random number */
    }

    alignment = 1;
    while (!(used_bits & alignment)) {
        alignment <<= 1;
    }

    printf("Alignment is: %lu\n", alignment);
    return 0;
}

Answer 2

Un alignement correct est au moins utile (en termes de performances) sur la plupart des implémentations x86 (et un certain type d'alignement est en fait obligatoire dans d'autres architectures). Vous pouvez demander (comme le fait calloc) une paire d'arguments, la taille des éléments en octets et le nombre d'éléments, plutôt qu'un seul (taille en octets, comme le fait malloc); vous pouvez ensuite vous aligner intrinsèquement (en arrondissant les tailles de bloc) à la puissance 2 supérieure à la taille de l'article (mais passer à des multiples de 16 octets au-dessus de 16, ne doublez pas indéfiniment, comme @derobert le recommande et l'explique! -). De cette façon, si un appelant veut seulement N octets sans alignement ni remplissage, il peut toujours demander N éléments de 1 octet chacun (comme ils le feraient avec calloc et pour la même raison; -).