MDXDave.de

Informatikstudent der TH Köln // Android + Coding

Laden...

Betriebssysteme Praktikum - Aufgabe 4.3 - Shared Memory

veröffentlicht vor 2 Jahren, am 8. Juni 2015  |  Praktikum    Betriebssysteme      |  0 Kommentare

BS Praktikum Aufgabensatz 4, Aufgabe 3: Shared Memory.

1. Was ist "Shared Memory"?

"Shared Memory" bedeutet auf Deutsch übersetzt in etwa "gemeinsam genutzter Speicher". Die Definition des IPC-Shared Memory (Interprocesscommunication): Hier nutzen zwei oder mehrere Prozesse einen bestimmten Teil des Hintergrundspeichers (RAM) gemeinsam. Konkreter gesagt bedeutet dies, dass wir mittels zwei unterschiedlichen Programmen auf denselben Speicher speicher zugreifen können und somit Daten zwischen den Programmen hin und her senden können.

2. Aufgabenstellung

Die Aufgabenstellung der Aufgabe 3 aus Aufgabensatz 4:

Schreiben Sie zwei C-Programme, welche über Shared Memory miteinander kommunizieren können. Das erste Programm allokiert einen Shared-Memory-Bereich. [...]
Das zweite Programm verlangt als Kommandozeilenparameter die durch prog1 ausgegebene ID des Shared-Memory Bereichs, gibt anschließend den darin befindlichen Text aus und entfernt den Shared-Memory-Bereich.

Wir müssen also zwei Programme erstellen. Programm eins schreibt einen übergebenen Text in den Shared-Memory und gibt die ID des Bereiches aus, Programm zwei liest den Shared-Memory Inhalt aus (die ID des Bereiches wird als Parameter übergeben) und gibt den Shared-Memory wieder frei.

3. Programm eins: "shm_create.c"

Wir erstellen eine neue Datei "shm_create.c" und schreiben die Standard-Funktion main():

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include #include 
#define SHMSZ 27
main(int argc, char *argv[])
{
    return 0;
}

Wie ihr sehen könnt, befindet sich im Kopf der Datei mehrere #include-Anweisungen, diese benötigen wir alle für unsere Funktionen.

Wir beginnen mit der Initialisierung der Variablen:

char c;
    int shmid, i;
    key_t key = 100;
    char *shm, *s;

Bei key können wir einen beliebigen Key festlegen, dies ist ein nummerischer (long) Schlüssel für das Segment. Wichtig ist, dass wir den Schlüssel sowohl in unserem ersten, als auch in unserem zweiten Programm identisch eintippen.

Als nächstes prüfen wir, ob ein Text übergeben wurde, falls nicht, beenden wir das Programm:

if(strlen(argv[1]) < 1){
    printf("Bitte übergeben Sie den Text, welcher im Shared-Mem gespeichert werden soll!");
    return 0;
}

Als letztes folgt nun der eigentliche Schreibprozess in das Shared-Memory Segment, der nachfolgende Code ist kommentiert und sollte so relativ simpel verstanden werden können:

//Erzeugen eines Shared-Memory Segments, inklusive Meldung im Fehlerfall
if ((shmid = shmget(key, SHMSZ, IPC_CREAT | 0666)) < 0) {
    perror("SHMGET Fehler");
    return 0;
}
// Hängt ein Segment an den Adressbereich an
if ((shm = shmat(shmid, NULL, 0)) == (char *) -1) {
    perror("SHMAT Fehler");
    return 0;
}
s = shm;
// Durchgehen unseres übergebene Strings und speichern im Shared-Memory
for (i=0; i<=strlen(argv[1]); i++)
    *s++ = argv[1][i];
*s = (int)NULL;
   
// Ausgabe der ID des Shared-Memory-Segments
printf("%d", shmid);

Anschließend noch ein

gcc shm_create.c -o create

und wir können unseren Text in den gemeinsamen Speicher schreiben:

./create "Dies ist ein Test! Shared Memory"

4. Programm zwei: "shm_read.c"

Programm zwei benötigen wir, damit wir den Shared Memory Inhalt wieder auslesen können.

Hierbei erstellen wir nun eine weitere Datei shm_read.c und fügen wieder unseren Kopfbereich mit Variablen ein:

#include <sys ipc.h="">
#include 
#define SHMSZ 27
main(int argc, char *argv[])
{
    int shmid;
    key_t key = 100;
    char *shm, *s;
    return 0;
}</sys>

Als nächstes wieder die Prüfung, ob eine Shared-Memory ID übergeben wurde:

if(strlen(argv[1]) < 1){
    printf("Bitte übergeben Sie die Shared-Mem ID!");
    return 0;
}

Nun müssen wir die übergeben ID richtig casten, sprich als korrekten Integer umwandeln, dies geschieht mittels:

shmid = (int)strtol(argv[1], NULL ,0);

... und wieder der kommentierte Hauptteil:

if ((shm = shmat(shmid, NULL, 0)) == (char *) -1) {
    perror("SHMAT Fehler"); 
    return 0;
}
// Zeichen für Zeichen auslesen
for (s = shm; *s != NULL; s++)
    putchar(*s);

Zuletzt sollten wir den Shared-Memory-Speicher wieder freigeben, dies erreichen wir durch

shmctl(shmid, IPC_RMID, NULL);

Das Programm kompilieren wir mittels

gcc shm_read.c -o read

und rufen es mittels der ID, welche wir aus unserem ersten Programm erhalten haben auf:

./read 13631515

5. Hinweise

Wie immer gilt natürlich, dass dieser Post lediglich als Hilfestellung gedacht ist. Ihr solltet die Aufgabe möglichst selbst lösen, da ihr auch die Klausur selbst schreiben müsst ;) Weitere Hilfe zu den einzelnen Befehlen gibt es mittels

man {BEFEHL}

oder bei stackoverflow/google usw.

Keine Gewähr für Richtigkeit.