son - sodimac embalaje

Relleno y embalaje de la estructura (7)

Considerar:

struct mystruct_A { char a; int b; char c; } x; struct mystruct_B { int b; char a; } y;

Los tamaños de las estructuras son 12 y 8 respectivamente.

¿Están estas estructuras acolchadas o empacadas?

¿Cuándo ocurre el relleno o el relleno?

( Las respuestas anteriores explicaron el motivo bastante claro, pero parece no estar del todo claro sobre el tamaño del relleno, así que añadiré una respuesta de acuerdo con lo que aprendo de The Lost Art of C Structure Packing )

Reglas de alineación de memoria - para struct

Reglas:

Antes de cada miembro individual, habrá relleno para que comience en una dirección que sea divisible por su tamaño. por ejemplo, en el sistema de 64 bits, int debe comenzar en la dirección divisible por 4, y largo por 8, corto por 2.
char y char [] es especial, podría ser cualquier dirección de memoria, por lo que no necesitan relleno antes que ellos.
Para la struct , aparte de la necesidad de alineación para cada miembro individual, el tamaño de la estructura completa se alineará con un tamaño divisible por el tamaño del miembro individual más grande, mediante el relleno al final. por ejemplo, si el miembro más grande de struct es largo, entonces es divisible por 8, int, luego por 4, corto, y por 2.

Orden de miembro:

El orden de miembro puede afectar el tamaño real de la estructura, así que tenlo en cuenta. por ejemplo, el stu_c y stu_d del ejemplo anterior tienen los mismos miembros, pero en diferente orden, y dan como resultado un tamaño diferente para la estructura.

Dirección en memoria - para struct

Reglas:

Sistema de 32 bits
Comienza desde (n * 8) bytes.
Motivo : el miembro de estructura individual más grande es de 8 bytes.
Sistema de 64 bits
Comienza desde (n * 16) bytes.
Motivo : el miembro de estructura individual más grande es de 16 bytes.

Espacio vacío :

El espacio vacío entre las estructuras podría ser utilizado por variables no estructurales que podrían caber.

Ejemplo

( para sistema de 64 bits )

memory_align.c :

/** * Memory align & padding - for struct. * compile: gcc memory_align.c * execute: ./a.out */ #include <stdio.h> // size is 8, 4 + 1, then round to multiple of 4 (int''s size), struct stu_a { int i; char c; }; // size is 16, 8 + 1, then round to multiple of 8 (long''s size), struct stu_b { long l; char c; }; // size is 24, l need padding by 4 before it, then round to multiple of 8 (long''s size), struct stu_c { int i; long l; char c; }; // size is 16, 8 + 4 + 1, then round to multiple of 8 (long''s size), struct stu_d { long l; int i; char c; }; // size is 16, 8 + 4 + 1, then round to multiple of 8 (double''s size), struct stu_e { double d; int i; char c; }; // size is 24, d need align to 8, then round to multiple of 8 (double''s size), struct stu_f { int i; double d; char c; }; // size is 4, struct stu_g { int i; }; // size is 8, struct stu_h { long l; }; // test - padding within a single struct, int test_struct_padding() { printf("%s: %ld/n", "stu_a", sizeof(struct stu_a)); printf("%s: %ld/n", "stu_b", sizeof(struct stu_b)); printf("%s: %ld/n", "stu_c", sizeof(struct stu_c)); printf("%s: %ld/n", "stu_d", sizeof(struct stu_d)); printf("%s: %ld/n", "stu_e", sizeof(struct stu_e)); printf("%s: %ld/n", "stu_f", sizeof(struct stu_f)); printf("%s: %ld/n", "stu_g", sizeof(struct stu_g)); printf("%s: %ld/n", "stu_h", sizeof(struct stu_h)); return 0; } // test - address of struct, int test_struct_address() { printf("%s: %ld/n", "stu_g", sizeof(struct stu_g)); printf("%s: %ld/n", "stu_h", sizeof(struct stu_h)); printf("%s: %ld/n", "stu_f", sizeof(struct stu_f)); struct stu_g g; struct stu_h h; struct stu_f f1; struct stu_f f2; int x = 1; long y = 1; printf("address of %s: %p/n", "g", &g); printf("address of %s: %p/n", "h", &h); printf("address of %s: %p/n", "f1", &f1); printf("address of %s: %p/n", "f2", &f2); printf("address of %s: %p/n", "x", &x); printf("address of %s: %p/n", "y", &y); // g is only 4 bytes itself, but distance to next struct is 16 bytes(on 64 bit system) or 8 bytes(on 32 bit system), printf("space between %s and %s: %ld/n", "g", "h", (long)(&h) - (long)(&g)); // h is only 8 bytes itself, but distance to next struct is 16 bytes(on 64 bit system) or 8 bytes(on 32 bit system), printf("space between %s and %s: %ld/n", "h", "f1", (long)(&f1) - (long)(&h)); // f1 is only 24 bytes itself, but distance to next struct is 32 bytes(on 64 bit system) or 24 bytes(on 32 bit system), printf("space between %s and %s: %ld/n", "f1", "f2", (long)(&f2) - (long)(&f1)); // x is not a struct, and it reuse those empty space between struts, which exists due to padding, e.g between g & h, printf("space between %s and %s: %ld/n", "x", "f2", (long)(&x) - (long)(&f2)); printf("space between %s and %s: %ld/n", "g", "x", (long)(&x) - (long)(&g)); // y is not a struct, and it reuse those empty space between struts, which exists due to padding, e.g between h & f1, printf("space between %s and %s: %ld/n", "x", "y", (long)(&y) - (long)(&x)); printf("space between %s and %s: %ld/n", "g", "y", (long)(&y) - (long)(&h)); return 0; } int main(int argc, char * argv[]) { test_struct_padding(); // test_struct_address(); return 0; }

Resultado de ejecución - test_struct_padding() :

stu_a: 8 stu_b: 16 stu_c: 24 stu_d: 16 stu_e: 16 stu_f: 24 stu_g: 4 stu_h: 8

Resultado de la ejecución - test_struct_address() :

stu_g: 4 stu_h: 8 stu_f: 24 address of g: 0x7fffd63a95d0 // struct variable - address dividable by 16, address of h: 0x7fffd63a95e0 // struct variable - address dividable by 16, address of f1: 0x7fffd63a95f0 // struct variable - address dividable by 16, address of f2: 0x7fffd63a9610 // struct variable - address dividable by 16, address of x: 0x7fffd63a95dc // non-struct variable - resides within the empty space between struct variable g & h. address of y: 0x7fffd63a95e8 // non-struct variable - resides within the empty space between struct variable h & f1. space between g and h: 16 space between h and f1: 16 space between f1 and f2: 32 space between x and f2: -52 space between g and x: 12 space between x and y: 12 space between g and y: 8

El embalaje de la estructura solo se realiza cuando le dices explícitamente a tu compilador que empaque la estructura. Relleno es lo que estás viendo. Su sistema de 32 bits está rellenando cada campo con la alineación de palabras. Si le hubieras dicho a tu compilador que empacara las estructuras, tendrían 6 y 5 bytes, respectivamente. No hagas eso sin embargo. No es portátil y hace que los compiladores generen un código mucho más lento (y a veces con errores).

El empaque de estructura suprime el relleno de la estructura, el relleno se usa cuando la alineación es más importante, el empaque se usa cuando más importa el espacio.

Algunos compiladores proporcionan #pragma para suprimir el relleno o para empaquetarlo en n cantidad de bytes. Algunos proporcionan palabras clave para hacer esto. Generalmente pragma que se usa para modificar el relleno de la estructura estará en el formato siguiente (depende del compilador):

#pragma pack(n)

Por ejemplo, ARM proporciona la palabra clave __packed para suprimir el relleno de la estructura. Consulte el manual del compilador para obtener más información al respecto.

Entonces, una estructura empaquetada es una estructura sin relleno.

Generalmente se usarán estructuras empaquetadas

para ahorrar espacio
formatear una estructura de datos para transmitir a través de la red usando algún protocolo (esta no es una buena práctica, por supuesto, porque necesita
lidiar con la endianidad)

La alineación de la estructura de datos es la forma en que se organizan los datos y se accede a ellos en la memoria de la computadora. Consiste en dos problemas separados pero relacionados: alineación de datos y relleno de la estructura de datos . Cuando una computadora moderna lee o escribe en una dirección de memoria, lo hará en trozos del tamaño de una palabra (por ejemplo, trozos de 4 bytes en un sistema de 32 bits) o más grande. La alineación de datos significa poner los datos en una dirección de memoria igual a un múltiplo del tamaño de la palabra, lo que aumenta el rendimiento del sistema debido a la forma en que la CPU maneja la memoria. Para alinear los datos, puede ser necesario insertar algunos bytes sin sentido entre el final de la última estructura de datos y el inicio de la siguiente, que es el relleno de la estructura de datos.

Para alinear los datos en la memoria, uno o más bytes vacíos (direcciones) se insertan (o se dejan vacíos) entre las direcciones de memoria que se asignan para otros miembros de la estructura mientras se asigna la memoria. Este concepto se llama relleno estructural.
La arquitectura de un procesador de computadora es tal que puede leer 1 palabra (4 bytes en procesador de 32 bits) de memoria a la vez.
Para hacer uso de esta ventaja del procesador, los datos siempre se alinean como un paquete de 4 bytes que lleva a insertar direcciones vacías entre la dirección de otro miembro.
Debido a este concepto de relleno de estructura en C, el tamaño de la estructura no siempre es el mismo que el que pensamos.

Relleno y embalaje son solo dos aspectos de la misma cosa:

embalaje o alineación es el tamaño al que se completa cada miembro
relleno es el espacio adicional agregado para que coincida con la alineación

En mystruct_A , suponiendo una alineación predeterminada de 4, cada miembro se alinea en un múltiplo de 4 bytes. Dado que el tamaño de char es 1, el relleno para a y c es 4 - 1 = 3 bytes, mientras que no se requiere relleno para int b que ya es de 4 bytes. Funciona de la misma manera para mystruct_B .

Sé que esta pregunta es antigua y la mayoría de las respuestas aquí explican el relleno muy bien, pero al tratar de entenderlo yo mismo me di cuenta de que tener una imagen "visual" de lo que estaba sucediendo me ayudó.

El procesador lee la memoria en "trozos" de un tamaño definido (palabra). Supongamos que la palabra del procesador tiene 8 bytes de longitud. Verá la memoria como una gran fila de bloques de construcción de 8 bytes. Cada vez que necesite obtener información de la memoria, alcanzará uno de esos bloques y la obtendrá.

Como parece en la imagen de arriba, no importa dónde esté un Char (1 byte de longitud), ya que estará dentro de uno de esos bloques, lo que requerirá que la CPU procese solo 1 palabra.

Cuando manejamos datos de más de un byte, como un byte de 4 bytes o un byte de 8 bytes, la forma en que están alineados en la memoria hace una diferencia en la cantidad de palabras que la CPU debe procesar. Si los trozos de 4 bytes están alineados de manera que siempre se ajustan al interior de un bloque (la dirección de memoria es un múltiplo de 4) solo se deberá procesar una palabra. De lo contrario, un trozo de 4 bytes podría tener una parte de sí mismo en un bloque y parte en otro, lo que requeriría que el procesador procesara 2 palabras para leer estos datos.

Lo mismo se aplica a un doble de 8 bytes, excepto que ahora debe estar en una dirección de memoria múltiple de 8 para garantizar que siempre estará dentro de un bloque.

Esto considera un procesador de texto de 8 bytes, pero el concepto se aplica a otros tamaños de palabras.

El relleno funciona llenando los espacios entre esos datos para asegurarse de que estén alineados con esos bloques, mejorando así el rendimiento mientras se lee la memoria.

Sin embargo, como se afirma en las respuestas de otros, a veces el espacio importa más que el rendimiento en sí mismo. Tal vez está procesando muchos datos en una computadora que no tiene mucha RAM (se podría usar espacio de intercambio pero es MUCHO más lento). Podría organizar las variables en el programa hasta que se realice el mínimo relleno (como se ejemplificó en gran medida en algunas otras respuestas), pero si eso no es suficiente, podría desactivar explícitamente el relleno, que es lo que es el empaque .

El relleno aligns los miembros de la estructura con los límites de direcciones "naturales", es decir, los miembros int tienen desplazamientos, que son mod(4) == 0 en la plataforma de 32 bits. El relleno está activado por defecto. Inserta los siguientes "espacios" en su primera estructura:

struct mystruct_A { char a; char gap_0[3]; /* inserted by compiler: for alignment of b */ int b; char c; char gap_1[3]; /* -"-: for alignment of the whole struct in an array */ } x;

El empaquetado , por otro lado, impide que el compilador realice el relleno (esto debe solicitarse explícitamente), según GCC es __attribute__((__packed__)) , por lo tanto, lo siguiente:

struct __attribute__((__packed__)) mystruct_A { char a; int b; char c; };

produciría una estructura de tamaño 6 en una arquitectura de 32 bits.

Una nota: el acceso a la memoria no alineada es más lento en las arquitecturas que lo permiten (como x86 y amd64), y está explícitamente prohibido en arquitecturas de alineación estrictas como SPARC.