Linux IPC - I.

A legegyszerűbben úgy kerülhetünk párhuzamos programozási környezetbe, ha veszünk egy hagyományos szekvenciális programozási nyelvet és kiegészítjük párhuzamos konstrukciókkal, például ahogyaan ebben az anyagrészben is eljárünk, ahol a C nyelvet egészítjük ki Linux rendszerhívásokkal.

A párhuzamos folyamatok közötti kommunikáció (IPC - Inter Process Communication) kifejezetten azokra a mechanizmusokra utal, amelyeket az operációs rendszer biztosít a folyamatok számára a közös adatok kezeléséhez. Ezzel a módszerrel akár közös memóriás, akár osztott memóriás modellben is programozhatunk.

A fork() hívás

A fork() hívás szolgál arra, hogy egy új folyamatot hozzunk létre a hívó folyamat duplikálásával. Ez nem a teljes hivó folyamatra vonatkozik a kezdetektől, hanem egy olyan lemásolt folyamatra, ami a fork() hívás helyétől kezdve fogja ugyanazt a programot futtatni. Erről a legegyszerűbben úgy is megbizonyosodhatunk, ha az alább található fork() hívásunk elé szintén elhelyezünk egy tetszőleges kiíratást (ez csak egyszer fog kiírásra kerülni - a duplikálás előtt csak egy folyamatunk volt).

Egy folyamatot bizonyos ideig szüneteltetni tudunk a sleep(unsigned int seconds) függvény segítségével, amely paraméterben a szüneteltés (altatás) hosszát várja másodpercben. Egészítsük ki a példánkat elegendően hosszú altatással a fork() hívás előtt és után is, majd futtasuk a programot. Nyissunk egy új terminált, és a ps -ao pid,ppid,psr,comm utasítás segítségével bizonyosodjunk meg róla, hogy a folyamat valóban megduplázódott (akár az utasítás többszöri kiadásával a terminálban).

#include <stdio.h>
#include <unistd.h> 

int main() {
  fork();
  printf("Hello world!\n");
}

Egészítsük ki a programunkat több fork() hívással. Az egymást követő n db fork() hívás 2^n db folyamatot eredményez. A fork és a sleep függvényeket használatához szükség lesz még az <unistd.h> header fájlra, ezen kívül a standard I/O műveletekre van még szükségünk (<stdio.h>).

Folyamatok azonosítói

Előző példában megnéztük hogy tudunk új processzt létrehozni, azonban ezeket a processzeket szeretnék azonosítani is valamilyen módon, illetve a folyamatok között alá- és fölérendeltségi viszonyt is meg szeretnék állapítani. Egy fork() hívás esetén tehát megkülönbözhetünk szülő és gyerek folyamatot: a függvényhívás visszatérési értéke 0 lesz gyerek folyamat esetén, nagyobb, mint 0 lesz szülő processz esetén, egyéb esetben pedig hiba történt a folyamat létrehozásakor. A pid_t típus egy signed int típust jelent, ami megegyezik a GNU C library esetén az int típussal (a hordozhatóság érdekében pid_t típust kellene használni).

Mintaprogramunk tartalmazza a gyermek folyamat esetén alkalmazandó _exit(EXIT_SUCCESS) és a szülő folyamat esetén alkalmazandó exit(EXIT_SUCCESS) függvényhívásokat (<stdlib.h>). Ezáltal megelőzhetjük a standard I/O pufferek (pl. stdout, stderr) többszöri kiírását, mielőtt a teljes programunk terminálna.

Fontos megjegyezni továbbá, hogy megkülönböztetjük a processzek azonosítóit a C programon belül és a folyamatok Linux rendszerbeli azonosítóit. Hogy lekérjük az adott folyamat azonosítóját, használjuk a getpid() függvényt, a folyamat szülőjéhez tartozó azonosító lekéréséhez pedig a getppid() függvényt. További érdekesség, hogy a C programon belül a szülő szál a gyerek folyamat Linux rendszerbeli azonosítóját kapja meg.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

void child(int pid) {
  printf("Child\n");
  _exit(EXIT_SUCCESS);
}

void parent(int pid) {
  printf("Parent\n");
  exit(EXIT_SUCCESS);
}

int main() {
  pid_t PID = fork();

  if (PID == 0) {
    child(PID);
  } else if (PID > 0) {
    parent(PID);
  } else {
    exit(EXIT_FAILURE);
  }
}

Virtuális memória

Ahhoz, hogy közös memóriát használó folyamatokat tudjunk létrehozni, további függvényhívásokra lesz majd szükség. Először viszont nézzük meg, hogyan reagál az alábbi program, ha egy közösnek tűnő változót mindkét folyamat módosítja:

#include <stdio.h>
#include <unistd.h>

int main() {
  int x = 1;

  if (fork() == 0)
    printf("Child has x = %d\n", --x);
  else
    printf("Parent has x = %d\n", ++x);
}

Ahogy látjuk, a két folyamat egymástól függetlenül módosítja a változó értékét. Amikor a fork() hívás megtörténik, a szülőhöz tartozó memóriaterületről másolat készül, amit a gyermek folyamat örököl. Előfordulhat, hogy a függvényhíváskor nem történik rögtön másolat, hanem a szülő és a gyermek folyamat megosztja egymás között a memóriaterületet, és csupán akkor készül el a másolat, amikor valamelyik folyamat módosítaná azt (lásd Copy-on-Write).

Másfelől, ha kiegészítjük a programunkat a változó memóriacímének kiíratásával, láthatjuk, hogy a két memóriacím megegyezik. Ez azonban nem jelenti azt, hogy a szülő és a gyermek folyamathoz tartozó változó ugyanazon a fizikai pozícióban van eltárolva. A modern számítógépek virtuális memóriacímzése miatt egyezik meg a memóriacím (azaz minden folyamat memóriája ugyanazon a virtuális címen kezdődik). Ezt szintén leellenőrizhetjük, ha az x változó címét kiiratjuk a programban.

Folyamatok ábrázolása

A következő példában gondoljuk végig hányszor kerül kiíratásra a "Hello world!" üzenet. Továbbra is igaz, hogy n fork() hívás esetén 2^n folyamat jön létre, azonban gondoljuk végig a (cikluson belüli) függvényhívások és a kiíratások sorrendjét.

#include<stdio.h>
#include<unistd.h>

int main() {
  for (int i = 0; i < 4; i++) {
    fork();
    printf("Hello world!\n");
  }

  // vs.

  fork();
  fork();
  fork();
  fork();
  printf("Hello world!\n");
}

Az egymást követő fork() hívások után létrejövő folyamatok könnyen ábrázolhatóak egy faként (draw.io forrás):

#include<stdio.h>
#include<unistd.h>

int main() {
  if (fork() || fork()) {
    fork();
  }
  printf("1 ");
}

Folyamatok bevárása és számuk korlátozása

Bizonyos esetekben szükség lehet arra, hogy az egyes folyamatok bevárják egymást, például ha egy adott problémát több részfeladatra bontottunk és a részfeladatokat feldolgozó (al)folyamatok különböző ideig számolnak, majd a részeredményeket összegezni szeretnék a fő folyamatban (tipikus példa: tömbösszegzés). Erre szolgál nekünk a wait(NULL) függvény (sys/wait.h), amellyel képes a programunk egy folyamatot bevárni (nem tudjuk megmondani, melyiket). További megkötés, hogy csak a szülő folyamat képes bevárni a gyerek folyamatokat a wait(NULL) segítségével. A szülő folyamat addig lesz blokkolva, amíg a gyermekfolyamat nem küld vissza egy kilépési állapotot az operációs rendszernek, a vezérlés aztán visszakerül a szülő folyamathoz (NULL helyett egy pointer segítségével a kilépési állapot logolható lenne - ezzel nem foglalkozunk).

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

void child() {
  sleep(3);
  printf("Child\n");
  _exit(EXIT_SUCCESS);
}

void parent() {
  wait(NULL);
  printf("Parent\n");
  exit(EXIT_SUCCESS);
}

int main() {
  pid_t PID = fork();

  if (PID == 0) {
    child();
  } else if (PID > 0) {
    parent();
  } else {
    exit(EXIT_FAILURE);
  }
}

Bizonyos esetben (vagy is inkább az esetek túlnyomó többségében) szükség van arra, hogy egy szülő folyamat bizonyos számú gyerek folyamatot hozzon létre anélkül, hogy a gyerek folyamatok további (al)folyamatok szülőjeként viselkedjen. Ezt a legkönyebben úgy érthetjük el, hogy a gyerek folyamatokat létrehozó ciklusból a break utasítás segítségével kilépünk. A manuálisan létrehozott szülő-gyerekfolyamatok nehezen menedzselhető párhuzamos programot eredményeznek!

Az n db létrehozott gyerek folyamat bevárásához n db wait(NULL) utasítás szükséges. Ebben a példában a gyerek folyamatok 3 másodpercig vannak szüneteltetve, azonban érdemes végiggondolni, hogy hogyan tudnánk különböző ideig szüneteltetni az egyes folyamatokat. Önmagában a "hagyományos módon" történő randomszám generálás nem jó megoldás, hiszen az egyes folyamatok ugyanabból a seed-ból indíthatják a pszeudorandom szám generálást (emlékeztetőül: szülő folyamat memóriaterületének lemásolása). Azonban kombinálhatjuk a random szám generálását egy egyedi azonosítóval, például minden folyamat rendelkezik egy Linux rendszerbeli egyedi azonosítóval (getpid()).

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <time.h>

void child() {
  sleep(3);
  printf("Child: %d\n", getpid());
  _exit(EXIT_SUCCESS);
}

void parent() {
  int i;
  for (i = 0; i < 4; i++) {
    printf("Waited: %d\n", wait(NULL));
  }
  exit(EXIT_SUCCESS);
}

int main() {
  int i;
  pid_t PID;

  for (i = 0; i < 4; i++) {
    PID = fork();

    if (PID == 0) {
      child();
      break;
    } else if (PID < 0) {
      exit(EXIT_FAILURE);
    } 
  }

  if (PID > 0) {
    parent();
  }
}

Gyakorló feladatok

(1) Mi az alábbi program kimenete és miért? Az indoklás egy lehetséges módja a folyamatok ábrázolása faként a korábbi példához hasonlóan. Használjunk egységes jelölést (pl. a bal részfa jelölje mindig >0 esetet, a jobb részfa pedig a =0 esetet).

#include<stdio.h>
#include<unistd.h>

int main() { 
    if (fork() && (!fork())) { 
        if (fork() || fork()) { 
            fork(); 
        } 
    } 
    printf("2 "); 
} 

(2) Készíts egy programot Linux IPC segítségével, amely egy 100 elemű, véletlenszerű számokkal feltöltött tömb összegzését végzi el négy gyerekfolyamat segítségével. Minden gyerekfolyamat a tömb egyenlő részét kapja meg, és kiszámítja a kapott intervallumban található számok összegét, majd az eredményt kiírja a standard kimenetre. A szülő folyamat feladata, hogy elindítsa a gyerekfolyamatokat, majd megvárja azok befejeződését.

Kapcsolódó linkek

Linux manual

---

Utolsó frissítés: 2025-02-23 11:46:35