Was ist eine “gepackte” Struktur in C?

Ich gehe durch einen C-Code, der für den Microchip C30-Compiler geschrieben wurde, und ich sehe oft Strukturen, die wie folgt definiert sind:

typedef struct __attribute__((__packed__)) 
{
    IP_ADDR     MyIPAddr;               // IP address
    IP_ADDR     MyMask;                 // Subnet mask
    IP_ADDR     MyGateway;              // Default Gateway
        // etc...
} APP_CONFIG;

Was bedeutet verpackt?

Wenn Strukturen definiert werden, darf der Compiler Paddings (Leerzeichen ohne eigentliche Daten) hinzufügen, damit Mitglieder in Adressgrenzen fallen, auf die die CPU leichter zugreifen kann.

Auf einer 32-Bit-CPU sollten 32-Bit-Mitglieder beispielsweise bei Adressen beginnen, die ein Vielfaches von 4 Bytes sind, um effizient auf sie zugreifen zu können (Lesen und Schreiben). Die folgende Strukturdefinition fügt eine 16-Bit-Auffüllung zwischen beiden Mitgliedern hinzu, sodass das zweite Mitglied in eine richtige Adressgrenze fällt:

struct S {
    int16_t member1;
    int32_t member2;
};

Die Speicherstruktur der obigen Struktur in einer 32-Bit-Architektur ist (~ = Polsterung):

+---------+---------+
| m1 |~~~~|   m2    |
+---------+---------+

Beim Packen einer Struktur werden diese Paddings nicht eingefügt. Der Compiler muss mehr Code generieren (der langsamer läuft), um die nicht ausgerichteten Datenelemente zu extrahieren und auch in sie zu schreiben.

Die gleiche Struktur erscheint, wenn sie gepackt ist, im Speicher als etwas wie:

+---------+---------+
| m1 |   m2    |~~~~
+---------+---------+

Es weist den Compiler an, keine Auffüllung zwischen Mitgliedern von hinzuzufügen struct.

Siehe zum Beispiel diese Seite.

Lassen Sie mich das Konzept des Auffüllens in Strukturen und dann von gepackten Strukturen anhand eines Beispiels erläutern.

Und dann lassen Sie uns sehen, warum eine Verpackung erforderlich ist.

Polsterung:

struct eg_struct
{
           unsigned char abc;
           unsigned int  xyz;
}

Wenn die Struktur wie oben auf einer 16-Bit-Architektur deklariert wird, wird die Variable abc würde eine Adresse zugewiesen werden. Die nächste Adresse wird nicht der Variablen zugewiesen xyzstattdessen wird ein zusätzliches Byte hinzugefügt, und dann würde der Variablen die nächste Adresse zugewiesen xyz.

Am Ende sieht die Struktur in etwa so aus:

struct eg_struct
{
           unsigned char abc;
           unsigned char paddedbytes[1];
           unsigned int  xyz;
}

Das Auffüllen macht Adressen von Mitgliedsvariablen für den Mikrocontroller leicht zugänglich. Der Nachteil sind zusätzliche unnötige Bytes, die ins Bild kommen.

Verpackung:

Wenn die gleiche Struktur mit dem Attribut „packed“, wird das zusätzliche Byte nicht nach der Variablen hinzugefügt abc.

Lassen Sie mich ein Beispiel geben, wo eine Verpackung erforderlich ist:

Stellen Sie sich einen Mikrocontroller vor, der mit einem EEPROM verbunden ist, in dem eine Struktur gespeichert wird.

Stellen Sie sich vor, eine Funktion, die in das EEPROM schreibt, würde wie folgt aussehen:

Write_EEPROM(EEPROM address, Ram address, Byte count);

Wenn nun das Packen nicht durchgeführt wird, würden die zusätzlichen aufgefüllten Bytes Platz im EEPROM belegen, was keinen Nutzen hat.

_attribute__((__packed__)) bedeutet (höchstwahrscheinlich) “keine Auffüllung einfügen, um die Dinge schneller zu machen” und kann auch bedeuten “keine Ausrichtungen einfügen, um die Ausrichtung beizubehalten”.

Eine Sache, die nicht ausdrücklich erwähnt wurde, ist, dass das Packen normalerweise so durchgeführt wird, dass es vordefinierten Feldstrukturen entspricht. Beispielsweise wird auf der unteren Ebene einer Netzwerkschnittstelle eine Reihe von Bytes zwischen vernetzten Maschinen ausgetauscht. Nachdem die Daten empfangen wurden, müssen sie einer übergeordneten Struktur zugeordnet werden, damit die Daten einfach bearbeitet werden können. In diesem Fall ist normalerweise kein Auffüllen erforderlich, sodass die Struktur direkt auf die Bytes abgebildet wird.

Der Netzwerkdatenaustausch beinhaltet auch ein Byte-Endianness-Problem (dh fast alle Netzwerkdaten verwenden das Big-Endian-Format, unabhängig von der Endianness der Quell- und Zielmaschinen).

Außerdem einige Maschinen kann nicht Greifen Sie auf breite Daten in nicht ausgerichteten Adressen zu, beispielsweise können Cortex-M0-Kerne nicht auf 32-Bit-Daten in nicht ausgerichteten 32-Bit-Adressen zugreifen, daher muss in solchen Fällen beim Schreiben von Netzwerkcode darauf geachtet werden.