C et de l'alignement de mémoire pour un protocole binaire

Question

je vais utiliser ce code, par exemple:

typedef struct __attribute__((aligned(XXX),packed)) 
{ 
    uint16_t type; 
    uint32_t id_index; 
} a_msg; 

void write_func(){ 
    a_mesg mymsg 
    mymsg.type = htons(1); 
    mymsg.id_index = htonl(5); 
    write(sock_fd, &mymsg, sizeof(a_mesg)); 
} 

void read_func(){ 
    a_mesg mymsg 
    read(sock_fd, &mymsg, sizeof(a_mesg)); 
    mymsg.type = ntohs(mymsg.type); 
    mymsg.id_index = ntohl(mymsg.id_index);  
} 

Note: sock_fd est un socket TCP. Ceci est un exemple un peu compressé et ne fonctionnerait peut-être pas mais je pense que vous voyez ce que j'essaye d'illustrer (un programme qui communique sur un protocole binaire).

Si l'application s'exécutait uniquement sur deux machines 32 bits communiquant entre elles via l'application, l'alignement (aligné (XXX)) serait naturellement défini sur 4. Si nous communiquons entre une machine 32 bits et une machine 64 bits, quel serait l'alignement?

1. XXX devrait être 4 sur 32 et machines 64 bits?
2. Est-ce que XXX doit être 8 sur les machines 32 et 64 bits?
3. Est-ce que XXX devrait être 8 sur 64 machines et 4 sur 32 bits?
4. XXX a une autre valeur.

Mon pari est sur autre 2.

Answer 1

que je fais

__attribute__((aligned(1),packed)) 

cela fonctionne =)

Answer 2

J'utiliser

#pragma pack 1 

sur les structures. Cela ne vous donne aucun remplissage, ce qui signifie moins de trafic net (moins d'octets à envoyer). Coulée facile.

ex:

struct S1 { 
    char c1; // Offset 0, 3 bytes padding 
    int i; // Offset 4, no padding 
    char c2; // Offset 8, 3 bytes padding 
}; // sizeof(S1)==12, alignment 4 

#pragma pack 1 

struct S2 { 
    char c1; // Offset 0, no padding 
    int i; // Offset 1, no padding 
    char c2; // Offset 5, no padding 
}; // sizeof(S2)==6, alignment 1 

Answer 3

je toujours utilisé des structures emballés pour tout protocole de comms. Moins de possibilités de confusion, pas de frais généraux inutiles, pas de moulage difficile pour éliminer le rembourrage à l'autre extrémité.