Diseño en memoria de una estructura. estructura de matrices y matriz de estructuras en C / C ++

En C / C ++ supongamos que defino una estructura simple llamada point siguiente manera.

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

Para una instancia específica de esta estructura, digamos que la test A es A.height, A.age, A.gender contiguos en la memoria?

De manera más general, ¿cómo se ven los diseños en memoria para una Estructura de matrices y una matriz de estructuras? Una imagen sería realmente útil.

No necesariamente serán contiguos en la memoria. Esto se debe al relleno de estructuras .

Sin embargo, en su caso particular, puede ser muy contiguo. Pero si cambiaste el orden a algo como esto:

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

entonces lo más probable es que no lo sean. Sin embargo, en su caso particular, es probable que obtenga relleno después del gender , para realinear la estructura a 8 bytes.


La diferencia entre SoA ( Struct of Arrays ) y AoS ( Array of Structs ) sería la siguiente:

SoA:

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

AoS:

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

Tenga en cuenta que las almohadillas de AoS dentro de cada estructura. Mientras SoA almohadillas entre las matrices.

Estos tienen las siguientes ventajas y desventajas:

  1. AoS tiende a ser más legible para el progtwigdor ya que cada “objeto” se mantiene unido.
  2. AoS puede tener una mejor localidad de caché si se accede a todos los miembros de la estructura.
  3. SoA podría ser potencialmente más eficiente ya que agrupar los mismos tipos de datos a veces expone la vectorización.
  4. En muchos casos, SoA usa menos memoria porque el relleno solo se produce entre las matrices en lugar de entre cada estructura.

Los campos individuales son contiguos en el sentido de que no habrá otras variables almacenadas entre ellos. También se garantiza que se almacenarán en el orden que usted declaró. Pero el comstackdor es libre de insertar relleno entre los campos individuales para alinear las cosas con los límites de las palabras, por ejemplo. Entonces lo siguiente:

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

puede verse así en la memoria:

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

En cuanto a la diferencia entre SoA y AoS, se presentan exactamente como se podría imaginar.

Además del descargo de responsabilidad estándar de “depende de su plataforma, comstackdor, blahblahblah” … sí, la height , la age y el gender serán contiguos en la memoria sin espacio entre ellos:

height|age|gender

Sin embargo, si tiene una matriz de test , cada elemento de la matriz tendrá relleno entre ellos después del gender de cada uno para que la height del siguiente elemento esté alineada correctamente.

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

Si su objective es utilizar la menor cantidad de memoria posible, entonces debe ir con “estructura de matrices”, ya que no utiliza relleno.

|height0|height1|...

|age0|age1|...

|gender0|gender1|...