arrière-plan: le compilateur peut insérer un remplissage dans une structure pour que les membres soient mieux alignés. Cela entraînera la taille de la structure étant plus grande que la somme des tailles de ses membres. La réorganisation des membres de la structure afin qu'elles pèvent mieux puissent retirer le besoin de coiffeur de cette manière et rendre la structure plus petite mémoire d'économie. J'ai besoin d'obtenir ces économies de mémoire.
L'option de replie est de vérifier toutes les structures à la main. Je cherche une approche automatisée qui peut réduire l'effort.
même s'il ne réduit que le nombre de structures à vérifier à la main qui aiderait.
Donc, par exemple, un processus / outil / etc. qui répertorie toutes les structures plus grandes que la somme des tailles de leurs membres, mais pas parfaite serait toujours utile car il limiterait ceux qui doivent être vérifiés manuellement.
Est-ce que quelqu'un connaît-il de tout outil qui peut faire cela ou que quelqu'un peut suggérer des approches qui pourraient aider?
P.s. J'ai besoin de le faire sur une base de code C intégrée contenant plus de 1 million de lignes de code.
4 Réponses :
Vous pouvez écrire un programme qui écrit à son tour un petit programme C pour chaque permutation des champs de la structure et lorsque le programme de sortie est compilé et exécutez ses impressions la taille de la structure. Cela deviendra peu pratique si le nombre de champs devient beaucoup plus grand que 10 ou plus.
Cela n'a pas trop de sens. En général, les champs de commande de la plus grande au moins génèrent un rembourrage optimal.
@Anon est-ce que cela reste vrai si des tailles de type ne sont pas des pouvoirs de deux, par exemple 10 octets étendus ou même Char T [5] ?
Un tableau de Char doit être commandé avec d'autres Char S - Peut-être serait peut-être plus précis de dire que les champs doivent être commandés par des exigences d'alignement.
@Anon je vois. Je pense que la version reformulée peut être prouvée mathématiquement, en supposant que (1) des alignements sont des pouvoirs de deux et (2) tailles sont des multiples d'alignements. Une fois, j'ai rencontré un compilateur dont la documentation semblait contredire (2), mais en fait, le compilateur l'a satisfait, la documentation n'était pas fausse.
@PASCAL: Les tailles doivent être multiples d'alignements, sinon le deuxième élément d'une matrice serait mal aligné. C a l'identité (char *) (p + 1) == (char *) p + taille de (* p) . Au moins, c'est ce que je pense que "contiguement alloué" dans la norme est censé vouloir dire - s'il y a des octets entre la fin de P [0] et le début de P [1], ils ne sont pas contigus.
@Steve c'est comme ça que nous sommes raisonnés. Pour ce que cela vaut, la documentation buggy que nous avons rencontrée semblait affirmer que des tableaux de caractère (de toutes tailles) seraient alignés sur une limite de 4 octets. Et c'était pour un "majeur" (comme le disent le protagoniste du club de combat) compilateur intégré.
AFAIK, il est légal de faire cela - disons que des tableaux de caractère seront alignés de cette façon, même si un caractère individuel ne serait pas. struct foo {char A; char b [1];}; est autorisé à avoir un remplissage entre A et B, même si char c [2] n'est pas autorisé à remplir le remplissage entre c [0] et c [1]. Que ce soit une bonne idée et que ce compilateur ait réellement fait ce qu'il a dit, sont indépendants de savoir si c'est légal :-)
Venez penser à cela, il y a une raison - de la même manière que MALLOC garantit que les allocations sont alignées sur n'importe quel objet, même s'il ne peut affecter qu'une matrice de caractère, vous pouvez créer un grand tableau de charcuterie à l'avant comme automatique ou Global, ou dans une structure qui est l'un de ceux-ci, puis l'utilise ultérieurement pour d'autres types. La programmation intégrée est d'environ 85% d'allocateurs personnalisés ;-)
CIL est un analyseur C robuste écrit dans OCAML qui comprennent le rembourrage des structures. Il est livré avec un programme de détection C. Le rembourrage des structures est spécifique à la plate-forme, je ne doute pas que vous le sachiez, mais vous auriez pu le rendre plus clair dans votre question. Le programme de détection emballé avec CIL détecte la taille des types et que l'algorithme qui suppose est utilisé pour le rembourrage des structures est que le décalage du champ N-T ème est calculé en arrondissant (décalage du champ (N-1) -TH. + Taille du champ (N-1) -TH) au multiple de (alignement du champ N-T ème le plus proche).
Ce serait moins de 200 lignes d'OCAML pour faire l'outil dont vous avez besoin, à partir de CIL. Mais il peut y avoir de meilleures solutions encore.
L'option d'avertissement de GCC de GCC peut être utilisée pour vous indiquer quand une structure est rembourrée. Cela ne vous dira pas lorsque la structure peut être faite plus petite, mais cela peut aider à réduire le travail.
Je me sens comme un idiot pour ne pas avoir trouvé cette option déjà.
Pahole est un utilitaire écrit pour cet objectif spécifique. Il analysera vos fichiers d'objet compilés (compilés avec débogage activé) et vous montrer les trous de structure.
est revenu et vous a avoué, vous l'avez utilisé pour un peu maintenant, je dois dire que Pahole est génial
La plupart des compilateurs ont une option pour emballer étroitement des structures - sur MSVC ++, ce document
/ ZP , sur GCC, c'est-FPACK-STRIT . Sachez que (1) Ceci allumera la compatibilité ABI avec les autres Code et (2) la plupart des CPU géreront des accès non alignés de données plus lentement (ou pas du tout sur certaines architectures).