Medziprocesová komunikácia - Zdieľana pamäť

Krok 1: Zdieľaná pamäť

Príprava

Pre prácu na cvičení si stiahnite súbor k cvičeniu.

Obsah súboru:

.
└── 08
    ├──u1_1.c
    ├──u1_2.c
    ├──Makefile
    └──tests

Úvod

Je to spôsob odovzdávania dát medzi dvoma nezávislými procesmi, ktorý je veľmi efektívny. Patrí medzi nástroje medziprocesovej komunikácie (IPC).

Rozlišuje sa: + fyzický adresný priestor (FAP) - operačná pamäť fyzicky prítomná v počítači, + logický adresný priestor procesu (LAP) - pamäť ako abstrakcia, na ktorú sa jednotlivé programy a procesy odvolávajú pri adresácií.

Zdieľaná pamäť je pamäťový segment, ktorý je mapovaný do adresných priestorov dvoch alebo viacerých procesov.

Proces mapovania pamäťového segmentu do adresného priestoru procesu je nasledovný:

Jeden proces vytvorí segment zdieľanej pamäte vo FAP. Procesy si potom môžu tento segment zdieľanej pamäti vo FAP „pripojiť“ ku svojmu vlastnému LAP. To znamená, že rovnaký segment operačnej pamäte počítača sa objaví v LAP niekoľkých procesov (pozri Obr. 1).

Ak v zdieľanej pamäti urobí jeden proces nejaké zmeny tak tieto zmeny budú hneď viditeľné všetkým ostatným procesom pristupujúcim k rovnakej zdieľanej pamäti. Zdieľaná pamäť ale neposkytuje spôsob synchronizácie k zdieľaným dátam a z toho dôvodu je potrebné túto synchronizáciu zaistiť.

Krok 2: Vytvorenie zdieľanej pamäte

Služba jadra shmget()

Služba shmget() vytvorí zdieľanú pamäť a vráti identifikátor na novovytvorenú pamäť.

#include <sys/ipc.h>
#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);

Príklad použitia:

#define _POSIX_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>

int main(){
    //Vytvorenie zdieľanej pamäte:
    int shm_id = shmget(12345,sizeof(char*),0666 | IPC_CREAT);
    if(shm_id!=-1){
        printf("Identifikator zdielanej pamate: %d.\n", shm_id);
        exit(0);
    }
    //V prípade chyby:
    else{
        perror("shmget(IPC_CREAT)");
        exit(1);
    }
}

Opis kódu:

Prostredníctvom služby shmget() je vytvorená zdieľaná pamäť s kľúčom 12345 a boli použité príznaky 0666 | IPC_CREAT.

Krok 3: Práca so zdieľanou pamäťou

Služba jadra shmctl()

Slúži na ovládanie zaregistrovaných zdieľaných pamätí.

#include <sys/types.h>
#include <sys/shm.h>

int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

Štruktúra shmid_ds:

struct shmid_ds {
    struct ipc_perm shm_perm;    /* Ownership and permissions */
    size_t          shm_segsz;   /* Size of segment (bytes) */
    time_t          shm_atime;   /* Last attach time */
    time_t          shm_dtime;   /* Last detach time */
    time_t          shm_ctime;   /* Last change time */
    pid_t           shm_cpid;    /* PID of creator */
    pid_t           shm_lpid;    /* PID of last shmat()/shmdt() */
    shmatt_t        shm_nattch;  /* No. of current attaches */
    ...
};

Príklad použitia:

#define _POSIX_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main(){
    //Vytvorenie zdieľanej pamäte:
    int shm_id = shmget(12345,sizeof(char*),0666 | IPC_CREAT);
    if(shm_id!=-1){
        printf("Identifikator zdielanej pamate: %d.\n", shm_id);
    }
    //V prípade chyby:
    else{
        perror("shmget(IPC_CREAT)");
        exit(1);
    }

    //Odstránenie zdieľanej pamäte:
    if(shmctl(shm_id, IPC_RMID, 0) == -1){
        //V prípade chyby:
        perror("shmctl(IPC_RMID) failed");
        exit(1);
    }
    printf("Zdielana pamat s ID = %d bola odstranena.\n", shm_id);
    exit(0);
}

Opis kódu:

Na začiatku je vytvorená zdieľaná pamäť. Následne je prostredníctvom služby shmctl() táto zdieľaná pamäť odstránená. To je zabezpečené použitím príznaku IPC_RMID.

Služba jadra shmat()

Keď je pamäť vytvorená operačným systémom, tak nie je prístupná žiadnemu procesu. Pomocou služby shmat() je možné pamäť pripojiť do adresného priestoru procesu a tým ju pre daný proces sprístupniť.

#include <sys/types.h>
#include <sys/shm.h>

void *shmat(int shm_id, const void *shm_addr, int shmflg);

Príklad použitia:

#define _POSIX_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main(){
    void *shared_memory = (void *)0;

    //Vytvorenie zdieľanej pamäte:
    int shm_id = shmget(12345,sizeof(char*),0666 | IPC_CREAT);
    if(shm_id!=-1){
        printf("Identifikator zdielanej pamate: %d.\n", shm_id);
    }
    //V prípade chyby:
    else{
        perror("shmget(IPC_CREAT)");
        exit(1);
    }

    //Pripojenie zdieľanej pamäte:
    shared_memory = shmat(shm_id, (void *)0, 0);
    if (shared_memory == (void *)-1) {
        //V prípade chyby:
        perror("shmat failed");
        exit(1);
    }
    printf("Smernik na prvy bajt zdielanej pamate: %X.\n", (int)shared_memory);

    //Odstránenie zdieľanej pamäte:
    if(shmctl(shm_id, IPC_RMID, 0) == -1){
        //V prípade chyby:
        perror("shmctl(IPC_RMID) failed");
        exit(1);
    }

    printf("Zdielana pamat s ID = %d bola odstranena.\n", shm_id);
    exit(0);
}

Opis kódu:

Po vytvorení zdieľanej pamäte je pamäť pripojená do adresného priestoru procesu prostredníctvom shmat().

Služba jadra shmdt()

Odpojí zdieľanú pamäť od LAP aktuálneho procesu.

#include <sys/types.h>
#include <sys/shm.h>

int shmdt(const void *shmaddr);

Príklad použitia:

#define _POSIX_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main(){
    void *shared_memory = (void *)0;

    //Vytvorenie zdieľanej pamäte:
    int shm_id = shmget(12345,sizeof(char*),0666 | IPC_CREAT);
    if(shm_id!=-1){
        printf("Identifikator zdielanej pamate: %d.\n", shm_id);
    }
    //V prípade chyby:
    else{
        perror("shmget(IPC_CREAT)");
        exit(1);
    }

    //Pripojenie zdieľanej pamäte:
    shared_memory = shmat(shm_id, (void *)0, 0);
    if (shared_memory == (void *)-1) {
        //V prípade chyby:
        perror("shmat failed");
        exit(1);
    }
    printf("Smernik na prvy bajt zdielanej pamate: %X.\n", (int)shared_memory);

    //Odpojenie zdieľanej pamäte:
    if (shmdt(shared_memory) == -1) {
        //V prípade chyby:
        perror("shmdt failed");
        exit(1);
    }
    else{
        printf("Zdielana pamat bola odpojena.\n");
    }

    //Odstránenie zdieľanej pamäte:
    if(shmctl(shm_id, IPC_RMID, 0) == -1){
        //V prípade chyby:
        perror("shmctl(IPC_RMID) failed");
        exit(1);
    }

    printf("Zdielana pamat s ID = %d bola odstranena.\n", shm_id);
    exit(0);
}

Opis kódu:

Potom, čo bola zdieľaná pamäť vytvorená a pripojená, bola následne pomocou služby shmdt() odpojena a následne odstránená.

Aplikovanie poznatkov v praxi

V tomto kroku sa nachádza príklad použitia, no v jeho kóde sa nachádzajú prázdne miesta. Namiesto nich doplňte správne odpovede v otázkach. Každá otázka je očíslovaná rovnakým číslom, aké je uvedené v kóde. Napríklad fragmentu kódu: [1......] odpovedá otázke č.1.

[1......]

u1_1.c

#define _POSIX_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>

struct shared_content {
    bool permission;
    char text[2048];
};

int main(){
    void *shared_memory = (void *)0;
    struct shared_content *shared_content;
    bool reading = true;

    //Vytvorenie procesu potomka pre program shm2.c:
    if(fork()==0){
        //Priradenie programu shm2.c pre proces potomka:
        [1......]("u1_2",(char *[]){NULL}, (char *[]){NULL});
        exit(0);
    }

    //Vytvorenie zdieľanej pamäte:
    int shm_id = [2......](1234,sizeof(struct shared_content),0666 | [3.........]);
    //V prípade chyby:
    if(shm_id==-1){
        exit(1);
    }

    //Pripojenie zdieľanej pamäte:
    shared_memory = [4.....](shm_id, (void *)0, 0);
    if(shared_memory == (void *)-1) {
        //V prípade chyby:
        exit(1);
    }

    //printf("Smernik na prvy bajt zdielanej pamate: %X.\n", (int)shared_memory);

    shared_content = (struct shared_content*) shared_memory;
    shared_content->permission = false;

    while(reading){
        if(shared_content->permission==true){
            printf("Zapisal si: %s", shared_content->text);
            sleep(rand() % 4);
            shared_content->permission = false;//Povolenie zápisu pre u1_2
            if(strncmp(shared_content->text, "end", 3) == 0) {
                reading = false;
                /*Ak používateľ zadá reťazec "end" tak sa ukončí vykonávanie a zdieľaná 
                pamäť sa odpojí a odstráni.*/
            }
        }
    }

    //Odpojenie zdieľanej pamäte:
    if([5.....](shared_memory) == -1) {
        //V prípade chyby:
        exit(1);
    }
    else{
        printf("Zdielana pamat bola odpojena.\n");
    }

    //Odstránenie zdieľanej pamäte:
    if([6......](shm_id, [7........], 0) == -1){
        //V prípade chyby:
        exit(1);
    }

    printf("Zdielana pamat s ID = %d bola odstranena.\n", shm_id);
    exit(0);
}

Opis kódu u1_1.c:

Na začiatku je vytvorený proces potomka, ktorému je priradený program u1_2.c. Následne je vytvorená zdieľaná pamäť pod kľúčom 1234. Tak je táto zdieľaná pamäť pripojená adresnému priestoru procesu rodiča. Po úspešnom pripojení je text zo zdieľanej pamäte vypísaný (len v prípade, že tam bol nejaký zapísaný - permission == true). Toto čítanie zo zdieľanej pamäte sa opakuje, pokiaľ používateľ nezadá na štandardný vstup reťazec "end". Po vykonávaní je zdieľaná pamäť odpojená a následne odstránená.

u1_2.c

#define _POSIX_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>

struct shared_content {
    bool permission;
    char text[2048];
};

int main(){
    void *shared_memory = (void *)0;
    struct shared_content *shared_content;
    bool reading = true;
    char buffer[BUFSIZ];

    //Vytvorenie zdieľanej pamäte:
    int shm_id = [2......](1234,sizeof(struct shared_content),0666 | IPC_CREAT);
    //V prípade chyby:
    if(shm_id==-1){
        exit(1);
    }

    //Pripojenie zdieľanej pamäte:
    shared_memory = [4.....](shm_id, (void *)0, 0);
    if(shared_memory == (void *)-1) {
        //V prípade chyby:
        exit(1);
    }

    //printf("Smernik na prvy bajt zdielanej pamate: %X.\n", (int)shared_memory);

    shared_content = (struct shared_content*) shared_memory;

    while(reading){
        while(shared_content->permission){
            sleep(1);
            printf("Cakanie na precitanie obsahu...\n");
        }
        printf("Vloz nejaky text: ");
        fgets(buffer, BUFSIZ, stdin);
        strncpy(shared_content->text, buffer, 2048);
        shared_content->permission = true;
        if(strncmp(buffer, "end", 3) == 0) {
            reading = false; 
            /*Ak používateľ zadá reťazec "end" tak sa ukončí vykonávanie a zdieľaná 
            pamäť sa odpojí.*/ 
        }
    }

    //Odpojenie zdieľanej pamäte:
    if ([5.....](shared_memory) == -1) {
        //V prípade chyby:
        exit(1);
    }
    else{
        printf("Zdielana pamat bola odpojena.\n");
    }
    exit(0);
}

Opis kódu u1_2.c:

Tento program sa spustí v procese potomka. Jedná sa o potomka rodiča, ktorý obsluhuje program u1_1.c. Najprv je získaný identifikátor na vytvorenú zdieľanú pamäť. Potom je, ako aj v prípade rodičovského procesu, zdieľaná pamäť pripojená do adresného priestoru procesu potomka. Pokiaľ nie je obsah pamäte prečítaný, tak do nej nie je možné nič zapisovať. Po tom, čo používateľ zadá reťazec "end" je zdieľaná pamäť odpojená od adresného priestoru procesu potomka.

Otázky: