Allineamento delle dimensioni della struct

Question

Desidero che la dimensione di una struct C sia multiplo di 16 byte (16B/32B/48B/..). Non importa a quale dimensione arriva, deve essere solo multiplo di 16B. Come posso far rispettare il compilatore per farlo? Grazie.

Answer 1

La dimensione di una struttura C dipenderà dai membri della struttura, i loro tipi e quanti di essi sono. Non c'è davvero un modo standard per forzare il compilatore a fare in modo che le strutture siano multiple di una certa dimensione. Alcuni compilatori forniscono un pragma che ti consentirà di impostare il limite di allineamento, tuttavia questa è davvero una cosa diversa. E potrebbe esserci qualcuno che avrebbe una tale impostazione o fornire un tale pragma.

Tuttavia, se si insiste su questo metodo sarebbe quello di fare l'allocazione della memoria della struct e per forzare l'allocazione di memoria per arrotondare alla prossima dimensione di 16 byte.

Quindi, se si ha una struttura come questa.

struct _simpleStruct { 
    int iValueA; 
    int iValueB; 
}; 

Quindi si potrebbe fare qualcosa come il seguente.

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

Che questo sarebbe fare è di spingere la dimensione fino alla prossima dimensione di 16 byte per quanto tu fossi interessato. Tuttavia, ciò che l'allocatore di memoria può o non può essere di darvi un blocco che è in realtà quella dimensione. Il blocco di memoria potrebbe effettivamente essere più grande della tua richiesta.

Se stai per fare qualcosa di speciale con questo, per esempio diciamo che stai andando a scrivere questa struttura in un file e vuoi conoscere la dimensione del blocco, allora dovresti fare lo stesso calcolo usato nel malloc() piuttosto che usare l'operatore sizeof() per calcolare la dimensione della struct.

Così la prossima cosa sarebbe quella di scrivere il proprio operatore proprio sizeof() utilizzando una macro come ad esempio.

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

quanto ne so non esiste un metodo affidabile per tirare la dimensione di un blocco allocato da un puntatore. Normalmente un puntatore avrà un blocco di allocazione di memoria che viene utilizzato dalle funzioni di gestione dell'heap della memoria che conterranno varie informazioni di gestione della memoria come la dimensione del blocco allocata che potrebbe essere effettivamente più grande della quantità di memoria richiesta. Tuttavia, il formato per questo blocco e dove si trova rispetto all'indirizzo di memoria effettivo fornito dipenderà dal tempo di esecuzione del compilatore C.

Answer 2

Questo dipende interamente dal compilatore e da altri strumenti poiché l'allineamento non è specificato in profondità nello standard ISO C (specifica che l'allineamento può verificarsi ai compilatori, ma non entra nei dettagli su come applicarlo).

Avrete bisogno di esaminare la roba attuazione specifiche per la vostra toolchain del compilatore. Può fornire uno #pragma pack (o align o qualche altra cosa) che è possibile aggiungere alla definizione della struttura.

Essa può anche fornire questo come un'estensione del linguaggio. Ad esempio, gcc consente di aggiungere attributi a una definizione, una delle quali controlla l'allineamento:

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

Answer 3

Per Microsoft Visual C++:

#pragma pack(push, 16) 

struct _some_struct 
{ 
    ... 
} 

#pragma pack(pop) 

Per GCC:

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

Esempio:

#include <stdio.h> 

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

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

compilato con gcc -o main main.c verrà emesso 16. Lo stesso vale per altri compilatori.

Answer 4

Si potrebbe forse fare un doppio struct, avvolgendo lo struct reale in un secondo che può aggiungere padding:

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)]; 
}; 

Poi si può lavorare con la struct imbottita:

struct payload_padded a; 

a.p.d = 43.3; 

Naturalmente , puoi fare uso del fatto che il primo membro di una struttura inizia a 0 byte da dove inizia la struttura e considera un puntatore a struct payload_padded come se fosse un puntatore a un struct payload (perché lo è):

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);