POSIX Shared Memory mit C -Programmierung

Der posix-Shared-Speicher ist ein Framework für Inter-Process Communication (IPC), das in den POSIX-Spezifikationen angegeben ist. Zwei (oder mehr) Aufgaben können daraus lesen und in die gemeinsame Speicherzone schreiben, während der gemeinsame Speicher festgelegt wird. Der in POSIX Shared Memory erzwungene Kopienauszahlungen erzwingt im Gegensatz zu anderen IPC -Strukturen nicht immer (e) im Gegensatz zu anderen IPC -Strukturen.G., Rohr, Steckdose usw.) und für bestimmte Programme wünschenswert ist.

POSIX Shared Speicheranrufe

Die POSIX Shared Memory -Funktionen konzentrierten sich auf das UNIX. Da Sie eine gegenseitige POSIX -Speichereinheit rezitieren und in eine gegenseitige POSIX -Speicher einschreiben, müssen letztere als Dokument betrachtet werden. Ein Speicher-abgebildeter Dokument ist eine POSIX Shared Memory Entity. Um die zu verwenden shm_open Systemanruffunktion darunter /dev/shm, Es werden separate gemeinsam genutzte Speicherdokumente generiert. Es gibt nur zwei dedizierte Shared Memory -Systemanrufe von POSIX, shm_open, Und shm_unlink, die eng mit dem Öffnungs- und Abnehmen von Dateisystemanrufen zusammenhängen. Der ftruncate, mmap, Und Munmap Framework -Aufrufe für Dokumente werden verwendet, um andere Aufgaben im POSIX -Shared -Speicher auszuführen. Es ist erforderlich, ein Programm zu verbinden, das POSIX Shared Speicheranrufe an verwendet -LRT.

Programme mit POSIX Shared Memory Calls müssen die folgenden Schritte ausführen:

Verwendung shm_open (), ein gemeinsam genutztes Speicherobjekt bilden. Der Dokumentdeskriptor kann zurückgekehrt werden, wenn die Bildung des Objekts erfolgreich ist.

Mit ftruncate (), Die Größe des Objekts wird behoben.

Mit Karte() Und Map_shared, Verringern Sie dieses Objekt in den vorliegenden Adressraum.

Lesen/Schreiben Sie den gemeinsam genutzten Speicher.

Über Munmap (), Un-Delineat das gemeinsame Speicher.

Verwenden schließen() das Objekt schließen.

Durch shm_unlink (), Löschen Sie das Objekt im gemeinsam genutzten Speicher.

shm_open ()

Wie oben beschrieben, shm_open () wird verwendet, um ein neues gemeinsames Speicherobjekt zu generieren. Es macht das Objekt mit dem zurückgekehrten Deskriptor für die Aufrufprozedur zugänglich. Das Folgende ist die Definition dieses Funktionsaufrufs:

>> int shm_open (const char *name, int oflag, modus_t modus);

Der erste Parameter ist der Name des gemeinsam genutzten Speicherobjekts. Es ist eine null-terminierte Schnur der /Name Typ, mit der Bestimmung, dass kein anderer Charakter ein anderer Schrägstrich als sein erster Charakter sein kann. Oflag ist ein kleiner Schleier, der mit mehreren der vorhergehenden Flags durch Or-ing erzeugt wurde, sei es via O_rdonly oder O_RDWR. Die beschriebenen Parameter zeigen, dass sein gemeinsam genutztes Memory-Objekt gebildet werden muss (O_Creat), wenn es noch nicht existiert, und auch das Objekt ist zum Lesen und Schreiben verfügbar (O_RDWR). Das allerletzte Argument legt die Verzeichnisgenehmigungen für das Shared-Memory-Objekt fest.

shm_unlink ()

Shm_unlink () eliminiert die früher entwickelte POSIX Shared Memory Entity, die früher entwickelt wurde. Der Integer-Dokument-Deskriptor für das Shared-Memory-Objekt wird über einen effektiven Aufruf an zurückgegeben shm_open (). Wie unter dem definiert shm_open (), Der Parametername ist der Titel der gemeinsam genutzten Speicherentität. Das Folgende ist die Definition der shm_unlink () Funktion:

>> int shm_unlink (const char *name);

ftruncate ()

Beim Einstellen des Objekts die ftruncate () Die Methode wird abgeschoben, um die Entitätsgröße in Bytes einzurichten. Die Funktionsdefinition lautet wie folgt:

>> int ftruncate (int fd, off_t länge);

Bei der Erstellung eines gemeinsam genutzten POSIX -Speichers sind es in der Tat keine Bytes der Größenkapazität. Sie können die POSIX -gemeinsame Speichereinheit mit Bytes der Größenlänge über übertragen ftruncate. Ftruncate ergibt bei der Ausführung Null. Ftruncate Ausgibt -1 bei einem Fehler und Errno wird so eingestellt, dass der Fehler ausgelöst wird.

mmap ()

Schließlich wird ein Speicher-abgebildetes Dokument mit der gemeinsam genutzten Entität über die festgelegt mmap () Methode. Anschließend ergibt es einen von einem Speicher abgebildeten Dokumentzeiger, der abgeschaltet wird, um die gemeinsame Entität mit gemeinsam genutzten Memory zu erreichen. Das Folgende ist die Definition der mmap () Funktion:

>> void *mmap (void *addr, size_t länge, int prot, int flags, int fd, off_t offset);

Darin ist 'ADDR' die Adresse, an die sie abgebildet wird. Die "Länge" ist der Bereich der gemeinsam genutzten Speichereinheit. Die Werte für Protokoll können sich unterscheiden, aber wir werden das Protokoll lesen | Protokoll schreiben. Es gibt mehrere Flags, aber MAP Shared ist für den gemeinsam genutzten Speicher unerlässlich. Jetzt ist 'FD' ein Dokument -Deskriptor, der zuvor erhalten wurde. Offset ist der Punkt, an dem die Zuordnung in der gemeinsamen Speicherentität beginnt. Der 0 -Offset -Wert kann ebenfalls verwendet werden. Bei Fertigstellung, mmap () Gibt den Zeiger auf die Zuordnungsposition der gemeinsam genutzten Speicherentität.

Munmap ()

An der von ADDR gerichteten Position und Erhalt der Größe, Länge, Munmap Entkackt das gemeinsam genutzte Speicherelement. Munmap ergibt 0 nach Abschluss und -1 in der Situation der Ungenauigkeit. In diesem Fall wird ERRNO zugewiesen, um den Fehler auszulösen.

>> void munmap (void *addr, size_t länge);

Beispiel: Absender und Empfänger

Nehmen wir das Beispiel des Absenders und des Empfängers. Der Absender erstellt mit dem Namen ein neues Shared-Memory-Objekt /SHMEM-Beispiel und einschreiben drei Ziffern in das gemeinsame Gedächtnis durch sie. Jetzt kann der Empfänger das gemeinsame Memory-Objekt freilegen und die drei Ziffern aus dem Speicher rezitieren. Wir erstellen drei Dateien mit den Namen Protokoll.H, Absender.C, Und Empfänger.C.

$ Touch Protokoll.H
$ Touch Sender.C
$ touchsempfänger.C

Als nächstes werden wir den folgenden Quellcode zum Protokoll der Dateien hinzufügen.H, "Absender.C, 'und Empfänger.C.„Jetzt werden wir alle retten und sie schließen.

Jetzt werden wir den oben genannten Code mit dem Schlüsselwort -lRT für den Absender zusammenstellen und verbinden.C und Empfänger.c Datei. Hier ist der Befehl, dies zu tun:

$ gcc -o Absender Absender.c -lrt
$ GCC -O -Empfängerempfänger.c -lrt

Jetzt werden wir den Absendercode über den folgenden Befehl ausführen. Die Ausgabe ist unten angegeben.

$ ./Absender

Ausführen des Absendungscode /dev/shm Verwenden Sie den folgenden Befehl:

$ ls -l /dev /shm | Grep Shmem-Beispiel

Wenn wir den Empfängercode ausführen, erhalten wir die folgende Ausgabe:

$ ./Empfänger

Wann immer die Funktion gm_unlink () wird unter Verwendung des Dateiempfängers aufgerufen.c, 'das Objekt /dev/shm/shmem-Beispiel wird abgelöst. In diesem Fall erhalten Sie kein Objekt für die Ausgabe, wie unten gezeigt.

$ ls -l/dev/shm/shmem -exampel

Abschluss

In diesem Artikel haben Sie gelernt, wie man mit COSIX Shared Memory mit C -Programmierung in Ubuntu 20 verwendet wird.04, einschließlich jedes Funktionsaufruf. Ich hoffe, dass dieser Artikel Ihnen geholfen hat, Ihr Programmierkenntnis zu verbessern, und alle Zweifel, die Sie zu diesem Thema haben.