optimisation des mises en page des structures C

Considérons une simple structure C :

struct foo {
    const char * str;
    unsigned char flag;
    uint64_t len;
};

Supposons que ce code soit exécuté dans le cadre d'un programme s'exécutant sur une machine 64 bits : quel serait le résultat de sizeof(struct foo) ?

La plupart des gens qui n'ont jamais eu à jouer avec les tailles et les optimisations des structures devineraient qu'il devrait être 17...

... mais il est 24 ! Pourquoi ?

La raison de ce comportement est que les compilateurs optimisent la disposition des structures pour plus de vitesse, et c'est la norme moderne selon laquelle les accès à la mémoire alignés sont le moyen le plus rapide d'accéder aux données.

Cela signifie que, selon le type de champ et de processeur, vos données auront un certain alignement et seront positionnées de telle sorte que cet alignement soit respecté (ou de telle sorte que field-address % field-alignment == 0).

taille, alignement, rembourrage

Dans le cas de l'exemple précédent, les pointeurs et les champs 64 bits sont alignés en 8B sur les machines 64 bits, ce qui signifie que, afin de forcer une mise en page où tout dans la structure est aligné, le compilateur générera des remplissage entre les champs flag et len :

Considérons maintenant un autre exemple, où une structure comme celle-ci est définie, sur la même machine qu'avant :

struct bar {
    const char * str;
    short s1;
    int i1
    short s2;
    int i2;
};

Comment calculer sa taille ?

Il y a trois règles :

• Les champs structurels veulent être alignés sur leur propre alignement naturel.
• L'alignement global de la structure est égal à l'alignement de son champ le plus large
• Si vous deviez mettre deux structures du même type côte à côte, la seconde doit être alignée sur son alignement -- cela signifie que les structures doivent avoir un remplissage de fin jusqu'à leur alignement

Récapitulatif rapide de l'alignement et de la taille des types de base pour les machines 64 bits :

type	size	alignment
char	1	1
short	2	2
int	4	4
long	8	8
float	4	4
double	8	8
pointers	8	8

Rappelez-vous également que :

• Les tableaux ont l'alignement de leur type de valeur et leur taille qui est sizeof(type) * nombre d'éléments.
• Les syndicats ont l'alignement et la taille de leur membre le plus large.

Et vous pouvez utiliser les opérateurs sizeof et _Alignof super utiles pour obtenir ces informations pour vos types personnalisés. Notez que _Alignof est disponible à partir de C11 et est appelé alignof à partir de C23. C'était toujours aligné d'après ce que je comprends en C , depuis C 11.

Pour plus d'informations, la bible sur ce sujet est The Lost Art of Structure Packing, à partir de laquelle j'ai appris presque tout ce que je sais à ce sujet, ainsi que beaucoup de pratique et d'expérience pratique.

optimiser vos structures : stropt

Ce sujet ici est quelque chose qui revient assez fréquemment au travail, où la sauvegarde d'octets ici et là est très importante lors de l'envoi continu d'énormes charges de données dans des files d'attente et ainsi de suite.

Afin de me faciliter la vie, j'ai écrit un outil qui produit des statistiques sur un type que vous passez en entrée, en référence à un fichier source ou un extrait de code, il s'appelle stropt (optimiseur de structure).

Abathargh/stropt sur GitHub

construire et installer

Si vous disposez d'une installation locale, vous pouvez continuer et créer ou installer l'application directement :

struct foo {
    const char * str;
    unsigned char flag;
    uint64_t len;
};

Des binaires déjà compilés pour une liste de combinaisons os/archs sont également fournis sur la page de version de github :

binaires stropt

en utilisant l'outil

Vous pouvez soit utiliser stropt en passant la source à analyser sous forme de chaîne :

struct bar {
    const char * str;
    short s1;
    int i1
    short s2;
    int i2;
};

Ou vous pouvez passer un fichier dans lequel la définition est contenue :

git clone https://github.com/Abathargh/stropt
go build

// or, if you want to install this directly
go install github.com/Abathargh/stropt

L'outil peut également fournir une optimisation possible de vos types en utilisant l'indicateur -optimize, et il connaît les champs qui sont eux-mêmes des structures :

Notez que l'indicateur détaillé est utilisé pour afficher les structures internes (et les unions) ainsi que l'alignement et la taille de leurs champs.

quelle est la prochaine étape

Cet outil a été écrit en Go en utilisant le formidable frontal du compilateur C modernc.org/cc pour analyser le code C et le lipgloss de charmbracelet pour l'interface utilisateur.

J'écris ceci pour moi mais je suis heureux de le partager publiquement ; J'aimerais en faire une application Web pour une utilisation plus facile directement dans un navigateur, donc c'est probablement la prochaine chose sur laquelle je vais travailler !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!