C struct la taille de l'alignement

Je veux de la taille d'une structure C est multiple de 16 octets (16B/32B/48B/..).
Il n'est pas question que de la taille, il l'obtient, il ne doit être un multiple de 16 TER.
Comment pourrais-je appliquer le compilateur de le faire?
Merci.

Quel est le compilateur?
Votre titre utilise le mot alignement cependant le corps de votre question parle de la taille de la structure. Qu'est-ce que vous voulez accomplir? Et je suis également curieux de savoir pourquoi.
Et voici un article qui propose une solution à l'aide d'une union à ventouse à une taille particulière. Cependant, cette solution nécessite la connaissance de la taille de la struct la Taille de Struct cependant, ce que vous devez faire est d'utiliser un calcul de la taille pour le char tableau, telles que (sizeof(struct)/16+1)*16 plutôt que d'un nombre constant.
Je suis actuellement à l'aide de gcc
La raison en est parce que j'ai un 16B aligné bloc de données et cette structure va être au début de la partie, et je veux encore le début de la réelle partie de données de la partie (après la struct) pour être aligné à la 16B pour de bon de l'ESS de la performance.

OriginalL'auteur Neo Hpcer | 2012-06-21

  1. 6

    De la taille d'une structure C dépendra de la les membres de cette structure, leurs types et combien d'entre eux y sont. Il n'y a vraiment aucun moyen standard pour forcer le compilateur à faire structures pour être un multiple de la taille. Certains compilateurs fournir un pragma qui va vous permettre de définir la limite d'alignement cependant, c'est vraiment autre chose. Et il peut y en avoir qui aurait un tel paramètre ou de fournir un tel pragma.

    Toutefois, si vous insistez sur cette méthode serait de faire de l'allocation de mémoire de la structure et de la force de l'allocation de mémoire pour le tour jusqu'à la prochaine 16 octets taille.

    Donc si vous aviez une structure de ce genre.

    struct _simpleStruct {
   int iValueA;
   int iValueB;
};

    Alors vous pourriez faire quelque chose comme ce qui suit.

    {
    struct _simpleStruct *pStruct = 0;
    pStruct = malloc ((sizeof(*pStruct)/16 + 1)*16);
    //use the pStruct for whatever
    free(pStruct);
}

    Ce que ce serait faire est de pousser à la taille jusqu'à la prochaine 16 octets taille d'autant que vous. Cependant, ce que l'allocateur de mémoire ne peut ou peut ne pas être pour vous donner un bloc qui est en réalité que la taille. Le bloc de mémoire peut être plus grande que votre demande.

    Si vous allez faire quelque chose de spécial c'est, par exemple, permet de dire que vous allez écrire cette structure d'un fichier et que vous voulez connaître la taille d'un bloc alors que vous auriez à faire le même calcul utilisé dans le malloc() plutôt que d'utiliser le sizeof() l'opérateur de calculer la taille de la structure.

    La prochaine chose serait d'écrire votre propre sizeof() de l'opérateur à l'aide d'une macro comme.

    #define SIZEOF16(x) ((sizeof(x)/16 + 1) * 16)

    Autant que je sache, il n'existe pas de méthode fiable pour tirer la taille d'un bloc alloué à partir d'un pointeur. Normalement, un pointeur de l'allocation de mémoire bloc qui est utilisé par la mémoire du tas de fonctions de gestion contiennent diverses de gestion de la mémoire des informations telles que la répartition de la taille d'un bloc qui peut être plus grande que la quantité de mémoire requise. Cependant, le format de ce bloc et où il est situé, par rapport à l'adresse de mémoire fourni dépend du compilateur C de la course du temps.

    Bonne réponse, mais il semble que si le type est déjà un multiple de 16 octets puis cette macro va ajouter un supplément de 16 octets à sa taille, potentiellement perdre la mémoire. Voici une alternative à l'aide de l'opérateur ternaire pour éliminer ce cas: #define SIZEOF16(x) ((sizeof(x) & 0x0F) ? (sizeof(x) + (0x10 - (sizeof(x) & 0x0F))) : sizeof(x))
    un bon point. Je suppose que mon problème est avec l'utilisation multiple de la macro argument. La plupart des gens ne savent pas, pour utiliser une expression qui modifie comme x++ dans une macro et que plus de la fonction de la recherche des choses qui sont tous en majuscules sont généralement une macro bien donc je suppose qu'il serait probablement assez inoffensif. Je suppose un inline fonction serait de faire aussi bien.
    De multiples utilisations dans une macro est une préoccupation valable, si sizeof est compris au moment de la compilation. Je ne peux pas imaginer qu'il soit utilisé comme ceci: SIZEOF16 = (x++) jamais, mais si oui, je pense qu'il y a peut-être une certaine façon de dire à GCC pour évaluer une macro argument une fois (ne me souviens pas sur le haut de ma tête).

    OriginalL'auteur Richard Chambers

  2. 12

    Pour Microsoft Visual C++:

    #pragma pack(push, 16)

struct _some_struct
{
     ...
}

#pragma pack(pop)

    Pour GCC:

    struct _some_struct { ... } __attribute__ ((aligned (16)));

    Exemple:

    #include <stdio.h>

struct test_t {
    int x;
    int y;
} __attribute__((aligned(16)));

int main()
{
    printf("%lu\n", sizeof(struct test_t));
    return 0;
}

    compilé avec gcc -o main main.c sortie 16. Il en va de même pour d'autres compilateurs.

    Pour gcc attribut aligné, est-il réellement forcer la structure de taille de plusieurs de 16B? Ou c'est juste qu'il garantir que l'adresse de début de la structure est aligné à 16B?
    À la fois l'adresse de début et la taille de la structure sera aligné à 16B. Ceci est fait afin d'assurer un alignement correct des éléments du tableau de structures.
    Ce n'est pas vrai. L' __attribut(dans l'axe(x))) macro alloue de la structure sur une x-frontière d'octet et n'a rien à voir avec la taille de la struct gcc.gnu.org/onlinedocs/gcc-3.2.3/gcc/Variable-Attributes.html
    Il est vrai (c'est implicite). Vérifiez vous-même. J'ai mis à jour ma réponse avec un exemple.
    Oui, ça l'est :).. my bad

    OriginalL'auteur VHaravy

  3. 5

    Cela dépend entièrement du compilateur et d'autres outils, car l'alignement n'est pas spécifié que profondément dans la norme ISO C standard (il spécifie que l'alignement peut arriver à les compilateurs demande, mais ne pas entrer dans les détails quant à la façon de l'appliquer).

    Vous aurez besoin de regarder dans la mise en œuvre spécifique des choses pour votre compilateur de la chaîne. Il peut fournir une #pragma pack (ou align ou autre chose) que vous pouvez ajouter à votre structure defininition.

    Il peut également fournir cela comme une extension du langage. Par exemple, gcc permet d'ajouter des attributs à une définition, un de qui contrôle l'alignement:

    struct mystruct { int val[7]; } __attribute__ ((aligned (16)));

    OriginalL'auteur paxdiablo

  4. 3

    Vous pourriez peut-être faire une double structure, habillage de votre structure dans un deuxième qui peut ajouter rembourrage:

    struct payload {
  int a;    /*Your actual fields. */
  float b;
  char c;
  double d;
};

struct payload_padded {
  struct payload p;
  char   padding[16 * ((sizeof (struct payload) + 15) / 16)];
};

    Alors vous pouvez travailler avec le collier de struct:

    struct payload_padded a;

a.p.d = 43.3;

    Bien sûr, vous pouvez utiliser le fait que le premier membre d'une structure commence à 0 octets d'où la structure commence, et de traiter un pointeur vers struct payload_padded comme si c'est un pointeur vers un struct payload (parce que c'est):

    float d_plus_2(const struct payload *p)
{
  return p->d + 2;
}

/* ... */

struct payload_padded b;
const double dp2 = d_plus_2((struct payload *) &b);

    OriginalL'auteur unwind