Operációs rendszerek 7.

B
Processzek közti kommunikáció (IPC)
Az IPC olyan módszerek összessége, amellyel több szálon párhuzamosan futó folyamatok
kommunikációja megvalósítható. A folyamatokat futhatnak egy vagy akár hálózatba kötött
számítógépen is.
Mivel a valóságban nem létezik független folyamat – legalább az erőforrásokért való
vetélkedés fennáll -, ezért is szükséges kommunikálniuk.
Használatuk lehetséges okai:
 információcsere
 számítási teljesítmény növelése
 modularitás
 kényelem
 jogok elkülönítése
Feladatai:
 Egymás közötti információcsere
 Erőforrások megosztása (ne keresztezzék egymást)
 Szinkronizáció (megfelelő sorrend kialakítása)
Fajtái:
 Szignálozás. Aszinkron, két processz közt aszimmetrikus, közvetlen, puffernélküli
csatorna; gyors, kis információmennyiséget átvivő.
 A szokásos “environment“-en keresztüli kommunikáció. Aszinkron, két processz közti
aszimmetrikus, puffer nélküli medence; gyors, kevés információ átvivő
 Fájlokon keresztüli kommunikáció. Aszinkron, sok processz közti, többnyire
aszimmetrikus, közvetett, medence; lassú, nagy információmennyiséget átvivő. Lehet
FIFO csatorna is (a neveztt pipe mechanizmus)
 A klasszikus üzenetsor (message queue) rendszer.
 Osztott memórián keresztüli kommunikáció.
 Szemaforok, mint kommunikációs mechanizmusok.
 A BSD socket kommunikáció.
 Remote Procedure Call.

Kommunikációs alapfogalmak
Blokkolás:
A folyamatok közti kommunikáció lehet:
 szinkron: küldés és fogadás is blokkolásos
 o send(): A hívás nem tér vissza, amíg az üzenetet nem vették (direkt) vagy az
nem került be a postaládába. Kommunikációs hiba esetén egy hibakezelő
callback függvény kerül meghívásra vagy időtúllépés történik és a send()
hibával tér vissza.
o receive(): a fogadás nem tér vissza addig, amíg nem érkezik üzenet
 aszinkron. küldés vagy fogadásos nem blokkolásos
o send():Az üzenet lokális elküldésének indítása után azonnal visszatér. Vagy
nincs hibakezelés, vagy callback függvény útján értesül róla a küldő folyamat
(pl. egy hibakezelő szálban).
o receive():azonnal visszatér
 ha van üzenet akkor azzal
 ha nincs üzenet, akkor azt jelzi (pl. üres üzenet, null referencia, stb.).

Címzés:
Az üzenetek küldése és fogadása lehet:
 kifejezett (explicit): a küldő meghatározott folyamatnak küld, a fogadó
meghatározott folyamattól fogad
 névtelen: (implicit): a küldés üzenetszórásos, a fogadó bárkitől fogad
A szinkron és kifejezett neveket használó (explicit naming) kommunikáció hasznos, szokásos.
Szinkronizációra kiváló. Blokkolós fogadás implicit (hiányzó) nevekkel hasznos.

Számosság:
A számosság a kommunikációban résztvevő folyamatok számát jelenti.
 explicit naming: 2 folyamat kommunikációja
 implicit naming: egy-a-többhöz vagy több-az-egyhez kommunikáció

Szimmetria:
A kommunikáció iránya, általában egyirányú (asszimmentrikus) vagy többirányú
(szimmetrikus).

Közvetettség:
 Direkt kommunikáció esetén a kommunikáló processzeknek ismerniük kell egymást.
Többnyire két processz közötti kommunikáció. Műveletei: küldés, fogadás (send,
receive), közben kiépül egy egy- vagy kétirányú kapcsolat pl. signal.
 Az indirekt kommunikáció esetén a processzeknek egy közvetítő entitást kell
ismerniük (üzenetsor, postaláda, stb.). A kommunikációban résztvevőknek
o létre kell hozni az entitást vagy csatlakozni hozzá,
o információ küldés, fogadás,
o elpusztítani az entitást.
Lehetnek különböző hozzáféréseik a kommunikáló processzeknek pl. file-okon
keresztüli kommunikáció, osztott memória, üzenetsor.
Az entitás kötődhet:
  processzhez: az egyik kommunikáló processz hozza létre, pusztítja el (processz
megszünésével, megszűnik)
 OS-hez: nem a kommunikáló processzek hozzák létre, szüntetik meg

Puffer kapacitás:
 zéró (nincs puffer): a kapcsolatnak nincs puffere, azaz a küldéssel egyidejűleg fogadni
kell (szinkronizációt igényel)
 van puffer: A küldés elválik a fogadástól. A küldéskor egy pufferbe kerül az
információ. A fogadó innen veszik ki az elsőt.
o korlátozott kapacitású: csak akkor kell várakozni a küldőnek, ha betelt a puffer
vagy a fogadónak ha üres a puffer.
o végtelen kapacitású: csak akkor kell várakozni a fogadónak, ha üres a puffer.

Primitív mechanizmusok:
 csatorna (channel): az üzenet eltűnik a csatornából, ha fogadjuk. Lehet közvetett és
közvetlen is. Pufferes változata lehet FIFO vagy FILO.
 medence (pool): a fogadott üzenet megmarad, többször is „kivehető”. Szokásosan
közvetett és szimmetrikus, lehet pufferelt is.

Példák
Szignál:
/* A SIGALRM szignált küld SVID stílusban (kill( )
rendszerhívással
az arguntumában adott azonosítójú (pid-ű) processznek.
*/

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>

int main(int argc, char **argv)

{
pid_t pid;
if(argc < 1) {
printf(" \n Nincs kinek, exitálok. \n");
exit(1);
}
pid = atoi(argv[1]);
kill(pid, SIGALRM); /* Itt a küldés! */
exit(0);
}

Környezeti változó (environment): (kéne példa)

Az operációs rendszer környezeti változóiba írás, illetve azok kiolvasása. Megvalósítás: A
burok környezeti változóit a processzek lekérdezhetik (getenv() rendszerhívás).
 Gyors, kis információtartalom mehet át.
  Indirekt, zéró pufferelt, változó üzenethosszos, aszimmetrikus.

Fájlokon keresztüli: (kéne példa)

Több processz ugyanabba a file-ba ír, file-ból olvas. Megvalósítás: a szokásos I/O
rendszerhívásokkal: open(), read(), write(), close().
 Lassú, nagy átvitt információtartalmú.
 Indirekt, OS kötődésű, szimmetrikus, pufferelt, változó üzenethosszos kommunikáció.

Üzenetsor (message queue)

 Gyors, közepes átvihető információmennyiség.
 Indirekt FIFO csatorna, OS kötődésű, többirányú, (elvileg) végtelen puffer kapacitású,
változó üzenethosszú.
 A rendszerhívások:
o msgget() // készítés, azonosítás
o msgctl() // kontroll, jellemzők lekérdezése, megszüntetés
o msgsnd() // üzenet betétel a sorba
o msgrcv() // üzenet kivétel a sorból
 Üzenetsor külső azonosítása: kulcs
 Üzenetsor belső azonosítása: egy változó
 A processzektől függetlenül létezik, ha készült.
 Tulajdonossági és hozzáférési jellemzőiket a fájl tulajdonossági, hozzáférési
kategóriák segítségével szabályozzák.
 Az ipcs paranccsal bizonyos jellemzőit lekérdhetjük. (Az ipcs az osztott memória és a
szemafor objektumokról is tájékoztat).
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#define KEY 1
#define PERM 0666

main(void)
{
int id; /* Üzenetsor belső leírója */
struct {long mtype; /* Az üzenet típusa */
char mtext[80]; /* Az üzenet teste */
} uzenet; /* Az uzenet struktúraváltozó */
int msgsize; /* Az üzenet mérethez */

/* Létrehozzuk a sort vagy beazonosítjuk */

if( (id = msgget(KEY, PERM | IPC_CREAT)) < 0) {
perror(" Nem hozható létre az üzenetsor. \n");
exit(-1);
}
 puts(" Kérek egy sort >");
gets(uzenet.mtext); /* Bemenetről egy sort olvasunk */
uzenet.mtype = 1; /* Legyen ez a típus */
msgsize = strlen(uzenet.mtext) + 1; /* Az üzenetméret */
/* Elküldjük az üzenetet */
msgsnd(id, (struct msgbuf *) &uzenet, msgsize, PERM);
}

Osztott memória (shared memory)

 Gyors, közepes információtartalmat átvivő
 Indirekt zérópufferelt medence, többirányú
 OS kötődésű. Védelme a fájlvédelmi mechanizmusokkal egyező
 Az érintett rendszerhívások:
o shmget( ); // készítés, beazonosítás
o shmat( ); // a processz címtartományára csatolás
o shmdt( ); // lecsatolás
o shmctl( ); // kontroll, jellemzők lekérdezése, beállítása, megszüntetés
Készítünk (beazonosítunk) adott méretű memória szegmenst. Ezt leképezzük a processz
címtartományára (megadjuk, milyen címeken és milyen típusként lássa a processz a
szegmens rekeszeit). Rácsatolódunk. Használjuk az adott címekre való hivatkozásokkal a
szegmens rekeszeit. Végül lekapcsoljuk a címtartományt, esetleg töröljük a szegmenst.
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define SHMKEY 123456L
#define KEY 0666
main()
{
int shmid; /* osztott mem azonosito */
key_t key; /* kulcs a shmem-hez */
int size=512; /* osztott szegmens meret */
key = SHMKEY;
/* Megnezzuk, van SHMKEY-es,size meretu szegmens. */
if ((shmid=shmget( key, size, 0)) < 0) {
printf("\n Nincs meg szegmens! Keszitsuk el!");
if ((shmid=shmget( key, size, KEY | IPC_CREAT)) < 0) {
perror("\n Az shmget system-call sikertelen!");
exit(-1);
}
} else printf("\n Van mar szegmens!");
printf(" Az shmid azonositoja %d: \n", shmid);
exit (0);
}