# Pragma Pack Effekt

Ich habe mich gefragt, ob mir jemand erklären könnte, was die #pragma packPräprozessor-Anweisung bewirkt und was noch wichtiger ist, warum man sie verwenden möchte.

Ich habe mir die MSDN-Seite angesehen , die einige Einblicke bot, aber ich hatte gehofft, mehr von erfahrenen Leuten zu hören. Ich habe es schon einmal im Code gesehen, obwohl ich anscheinend nicht mehr finde, wo.

#pragma packWeist den Compiler an, Strukturelemente mit einer bestimmten Ausrichtung zu packen. Die meisten Compiler fügen beim Deklarieren einer Struktur einen Abstand zwischen den Elementen ein, um sicherzustellen, dass sie an den entsprechenden Adressen im Speicher ausgerichtet sind (normalerweise ein Vielfaches der Größe des Typs). Dies vermeidet die Leistungseinbußen (oder Fehler) bei einigen Architekturen, die mit dem Zugriff auf Variablen verbunden sind, die nicht richtig ausgerichtet sind. Beispiel: Geben Sie 4-Byte-Ganzzahlen und die folgende Struktur an:

struct Test
{
   char AA;
   int BB;
   char CC;
};

Der Compiler kann die Struktur wie folgt im Speicher anordnen:

|   1   |   2   |   3   |   4   |  

| AA(1) | pad.................. |
| BB(1) | BB(2) | BB(3) | BB(4) | 
| CC(1) | pad.................. |

und sizeof(Test)wäre 4 × 3 = 12, obwohl es nur 6 Datenbytes enthält. Der häufigste Anwendungsfall für #pragma(meines Wissens) ist die Arbeit mit Hardwaregeräten, bei denen Sie sicherstellen müssen, dass der Compiler keine Auffüllungen in die Daten einfügt und jedes Mitglied dem vorherigen folgt. Mit #pragma pack(1)würde die obige Struktur wie folgt aufgebaut sein:

|   1   |

| AA(1) |
| BB(1) |
| BB(2) |
| BB(3) |
| BB(4) |
| CC(1) |

Und sizeof(Test)wäre 1 × 6 = 6.

Mit #pragma pack(2)würde die obige Struktur wie folgt aufgebaut sein:

|   1   |   2   | 

| AA(1) | pad.. |
| BB(1) | BB(2) |
| BB(3) | BB(4) |
| CC(1) | pad.. |

Und sizeof(Test)wäre 2 × 4 = 8.

Die Reihenfolge der Variablen in struct ist ebenfalls wichtig. Mit Variablen, die wie folgt geordnet sind:

struct Test
{
   char AA;
   char CC;
   int BB;
};

und mit #pragma pack(2)würde die Struktur so angelegt sein:

|   1   |   2   | 

| AA(1) | CC(1) |
| BB(1) | BB(2) |
| BB(3) | BB(4) |

und sizeOf(Test)wäre 3 × 2 = 6.

#pragmawird verwendet, um nicht portierbare Nachrichten (wie nur in diesem Compiler) an den Compiler zu senden. Dinge wie das Deaktivieren bestimmter Warnungen und Verpackungsstrukturen sind häufige Gründe. Das Deaktivieren bestimmter Warnungen ist besonders nützlich, wenn Sie mit den Warnungen kompilieren, wenn das Fehlerflag aktiviert ist.

#pragma packwird speziell verwendet, um anzuzeigen, dass die Elemente der zu packenden Struktur nicht ausgerichtet sein sollten. Dies ist nützlich, wenn Sie eine speicherabgebildete Schnittstelle zu einer Hardware haben und genau steuern müssen, wohin die verschiedenen Strukturelemente zeigen. Dies ist insbesondere keine gute Geschwindigkeitsoptimierung, da die meisten Maschinen viel schneller mit ausgerichteten Daten umgehen können.

Es teilt dem Compiler die Grenze mit, an der Objekte in einer Struktur ausgerichtet werden sollen. Zum Beispiel, wenn ich so etwas habe wie:

struct foo { 
    char a;
    int b;
};

Bei einer typischen 32-Bit - Maschine, würden Sie normalerweise „wollen“ hat drei Bytes padding zwischen aund bso , dass bbei einer 4-Byte - Grenze landen wird seine Zugriffsgeschwindigkeit zu maximieren (und das ist , was typischerweise durch Standard passieren wird).

Wenn Sie jedoch mit einer extern definierten Struktur übereinstimmen müssen, möchten Sie sicherstellen, dass der Compiler Ihre Struktur genau gemäß dieser externen Definition auslegt. In diesem Fall können Sie den Compiler geben ein , #pragma pack(1)ihm zu sagen , nicht jede Polsterung zwischen den Mitgliedern einzusetzen - wenn die Definition der Struktur Polsterung zwischen den Mitgliedern enthält, können Sie es explizit einfügen (zB typischerweise mit Mitgliedern genannt unusedNoder ignoreN, oder etwas auf , dass Auftrag).

Datenelemente (z. B. Mitglieder von Klassen und Strukturen) werden normalerweise an WORD- oder DWORD-Grenzen für Prozessoren der aktuellen Generation ausgerichtet, um die Zugriffszeiten zu verbessern. Das Abrufen eines DWORD an einer Adresse, die nicht durch 4 teilbar ist, erfordert mindestens einen zusätzlichen CPU-Zyklus auf einem 32-Bit-Prozessor. Wenn Sie also z. B. drei Zeichenmitglieder haben char a, b, c;, benötigen diese tatsächlich 6 oder 12 Byte Speicherplatz.

#pragmaMit dieser Option können Sie diese überschreiben, um eine effizientere Speicherplatznutzung auf Kosten der Zugriffsgeschwindigkeit oder eine Konsistenz der gespeicherten Daten zwischen verschiedenen Compilerzielen zu erzielen. Ich hatte viel Spaß beim Übergang von 16-Bit- zu 32-Bit-Code. Ich gehe davon aus, dass die Portierung auf 64-Bit-Code bei einigen Codes die gleichen Kopfschmerzen verursacht.

Der Compiler kann Elemente in Strukturen ausrichten, um auf der bestimmten Plattform maximale Leistung zu erzielen. #pragma packMit der Direktive können Sie diese Ausrichtung steuern. Normalerweise sollten Sie es standardmäßig belassen, um eine optimale Leistung zu erzielen. Wenn Sie eine Struktur an den Remote-Computer übergeben müssen, werden Sie im Allgemeinen verwendet #pragma pack 1, um unerwünschte Ausrichtungen auszuschließen.

Ein Compiler kann Strukturelemente aus Gründen der Leistung auf einer bestimmten Architektur an bestimmten Bytegrenzen platzieren. Dies kann zu unbenutzten Polstern zwischen den Mitgliedern führen. Die Strukturpackung zwingt die Elemente dazu, zusammenhängend zu sein.

Dies kann beispielsweise wichtig sein, wenn Sie eine Struktur benötigen, die einer bestimmten Datei oder einem bestimmten Kommunikationsformat entspricht, in dem sich die Daten, die Sie benötigen, an bestimmten Positionen innerhalb einer Sequenz befinden müssen. Eine solche Verwendung befasst sich jedoch nicht mit Endianitätsproblemen. Obwohl sie verwendet wird, ist sie möglicherweise nicht portabel.

Es kann auch sein, dass die interne Registerstruktur eines E / A-Geräts wie beispielsweise eines UART- oder USB-Controllers genau überlagert wird, damit der Registerzugriff über eine Struktur und nicht über direkte Adressen erfolgt.

Sie möchten dies wahrscheinlich nur verwenden, wenn Sie auf einer Hardware (z. B. einem Gerät mit Speicherzuordnung) codieren, für die strenge Anforderungen an die Reihenfolge und Ausrichtung der Register gestellt wurden.

Dies scheint jedoch ein ziemlich stumpfes Werkzeug zu sein, um dieses Ziel zu erreichen. Ein besserer Ansatz wäre, einen Minitreiber in Assembler zu codieren und ihm eine C-Aufrufschnittstelle zu geben, anstatt mit diesem Pragma herumzufummeln.

Ich habe es schon einmal im Code verwendet, allerdings nur als Schnittstelle zu Legacy-Code. Dies war eine Mac OS X Cocoa-Anwendung, die Voreinstellungsdateien aus einer früheren Carbon-Version laden musste (die selbst abwärtskompatibel mit der ursprünglichen M68k System 6.5-Version war ... Sie haben die Idee). Die Voreinstellungsdateien in der Originalversion waren ein binärer #pragma pack(1)Speicherauszug einer Konfigurationsstruktur, mit dem vermieden wurde, zusätzlichen Speicherplatz zu beanspruchen und Junk zu sparen (dh die Füllbytes, die sich sonst in der Struktur befinden würden).

Die ursprünglichen Autoren des Codes hatten auch #pragma pack(1)Strukturen gespeichert, die als Nachrichten in der Kommunikation zwischen Prozessen verwendet wurden. Ich denke, der Grund hier war, die Möglichkeit unbekannter oder geänderter Auffüllgrößen zu vermeiden, da der Code manchmal einen bestimmten Teil der Nachrichtenstruktur betrachtete, indem er von Anfang an eine Anzahl von Bytes zählte (ewww).

Ich habe gesehen, dass Leute es verwenden, um sicherzustellen, dass eine Struktur eine ganze Cache-Zeile benötigt, um eine falsche Freigabe in einem Multithread-Kontext zu verhindern. Wenn Sie eine große Anzahl von Objekten haben, die standardmäßig lose gepackt werden, kann dies Speicherplatz sparen und die Cache-Leistung verbessern, um sie enger zu packen, obwohl ein nicht ausgerichteter Speicherzugriff normalerweise die Dinge verlangsamt, sodass möglicherweise ein Nachteil auftritt.

Beachten Sie, dass es andere Möglichkeiten gibt, Datenkonsistenz zu erreichen, die #pragma pack bietet (zum Beispiel verwenden einige Leute #pragma pack (1) für Strukturen, die über das Netzwerk gesendet werden sollen). Siehe zum Beispiel den folgenden Code und seine nachfolgende Ausgabe:

#include <stdio.h>

struct a {
    char one;
    char two[2];
    char eight[8];
    char four[4];
};

struct b { 
    char one;
    short two;
    long int eight;
    int four;
};

int main(int argc, char** argv) {
    struct a twoa[2] = {}; 
    struct b twob[2] = {}; 
    printf("sizeof(struct a): %i, sizeof(struct b): %i\n", sizeof(struct a), sizeof(struct b));
    printf("sizeof(twoa): %i, sizeof(twob): %i\n", sizeof(twoa), sizeof(twob));
}

Die Ausgabe ist wie folgt: sizeof (Struktur a): 15, sizeof (Struktur b): 24 sizeof (twoa): 30, sizeof (twob): 48

Beachten Sie, wie die Größe der Struktur a ist genau das, was die Byte - Zählung, aber struct b hat padding hinzugefügt (siehe diese Einzelheiten über die Polsterung). Auf diese Weise können Sie im Gegensatz zum # Pragma-Paket steuern, ob das "Drahtformat" in die entsprechenden Typen konvertiert wird. Zum Beispiel "char two [2]" in ein "short int" und so weiter.

Warum will man es benutzen?

Den Speicher der Struktur reduzieren

Warum sollte man es nicht benutzen?

1. Dies kann zu Leistungseinbußen führen, da einige Systeme bei ausgerichteten Daten besser funktionieren
2. Einige Computer können nicht ausgerichtete Daten nicht lesen
3. Code ist nicht portabel