web-dev-qa-db-fra.com

Mise en page en mémoire d'une structure. structure de tableaux et tableau de structures en C/C++

En C/C++, supposons que je définis une structure simple nommée point comme suit. 

struct test
{
double height;
int    age;
char   gender;
}

Pour une instance spécifique de cette structure, dites test A sont A.height, A.age, A.gender contigusin mémoire? 

Plus généralement, à quoi ressemblent les dispositions en mémoire pour une structure de tableaux et un tableau de structures? Une photo serait vraiment utile. 

c++carraysstruct
36
smilingbuddha

Ils ne seront pas nécessairement contigus en mémoire. Cela est dû à struct padding .

Toutefois, dans votre cas particulier, il se peut très bien que ce soit contigu. Mais si vous avez changé l'ordre en quelque chose comme ceci:

struct test
{
    char   gender;
    int    age;
    double height;
}

alors ils ne le seront probablement pas. Cependant, dans votre cas particulier, vous obtiendrez probablement un remplissage après gender pour réaligner la structure sur 8 octets.

La différence entre SoA (Struct of Arrays) et AoS (Array of Structs) serait la suivante:

SoA:

-----------------------------------------------------------------------------------
| double | double | double | *pad* | int | int | int | *pad* | char | char | char |
-----------------------------------------------------------------------------------

AoS:

-----------------------------------------------------------------------------------
| double | int | char | *pad* | double | int | char | *pad* | double | int | char |
-----------------------------------------------------------------------------------

Notez que les pads AoS de chaque structure. Alors que SoA se situe entre les tableaux.

Ceux-ci ont les compromis suivants:

  1. AoS tend à être plus lisible par le programmeur car chaque "objet" est maintenu ensemble.
  2. AoS peut avoir une meilleure localisation en cache si tous les membres de la structure sont accédés ensemble.
  3. SoA pourrait potentiellement être plus efficace, car regrouper les mêmes types de données expose parfois la vectorisation.
  4. Dans de nombreux cas, SoA utilise moins de mémoire car le remplissage est uniquement entre tableaux et non entre chaque structure.
62
Mysticial

Les champs individuels sont contigus en ce sens qu’aucune autre variable ne sera stockée entre eux. Ils sont également garantis d'être stockés dans l'ordre que vous avez déclaré. Mais le compilateur est libre d'insérer un remplissage entre les champs individuels pour aligner les éléments sur les limites de Word, par exemple. Donc ce qui suit:

struct test
{
    double height;
    char   gender;
    int    age;
};

peut ressembler à ceci en mémoire:

         +7  +6  +5  +4  +3  +2  +1  +0
        +---+---+---+---+---+---+---+---+
0x0000  |            height             |
        +---+---+---+---+---+---+---+---+
0x0008  |      age      |           |gen|
        +---+---+---+---+---+---+---+---+

En ce qui concerne la différence entre SoA et AoS, elles sont présentées exactement comme vous pouvez l’imaginer.

7
Oliver Charlesworth

Autre que l'avertissement standard de "cela dépend de votre plate-forme, du compilateur, de blahblahblah" ... oui, height, age et gender seront contigus en mémoire sans remplissage entre:

height|age|gender

Cependant, si vous avez un tableau de test, chaque élément de tableau sera intercalé après chaque gender afin que le prochain élément height soit correctement aligné.

|height0|age0|gender0|padding0|height1|age1|gender1|padding1|...

Si votre objectif est d'utiliser le moins de mémoire possible, choisissez plutôt "structure de tableaux", car il n'utilise aucun remplissage.

|height0|height1|...

|age0|age1|...

|gender0|gender1|...

0
Jim Buck