Procesy a vlákna – IPC Komunikace mezi procesy (IPC = Inter

ÚVOD DO OPERAČNÍCH SYSTÉMŮ
Ver.1.00
Procesy a vlákna – IPC
Komunikace mezi procesy
(IPC = Inter-Process Communication)
České vysoké učení technické Fakulta elektrotechnická
A7B38UOS Úvod do operačních systémů 07 - IPC
2012
Použitá literatura
[1] Stallings, W.: Operating Systems. Internals and Design Principles. 4th
Edition. Prentice Hall, New Jersey, 2001.
[2] Silberschatz, A. – Galvin, P. B. - Gagne, G. : Operating System Concepts.
6th Edition. John Wiley & Sons, 2003.
[3] Tanenbaum, A.: Modern Operating Systems. Modern Operating Systems.
Prentice Hall, New Jersey, 2008.
A7B38UOS Úvod do operačních systémů 07 - IPC
Komunikace mezi procesy (IPC)
Meziprocesová komunikace (IPC) = výměna informací (např. dat) mezi
dvěma nebo více procesy/vlákny
ƒ zahrnuje metody synchronizace procesů (semafor, mutex, monitor –
viz přednáška č. 6), zasílání zpráv, sdílení paměti, vzdálené volání
procedur, aj.
ƒ při programování se využívá API dané obecným standardem
(POSIX=IEEE 1003, SUS Single Unix Specification), příslušnou
platformou (Win32 API) nebo jednoúčelovou implementací
ƒ může probíhat na jednom příp. více počítačích propojených
počítačovou sítí
A7B38UOS Úvod do operačních systémů 07 - IPC
IPC: Zasílání zpráv (Message Passing)
Základní operace:
send(destination,&message)
receive(source,&message)
send() – vysílá zprávu na dané cílové místo;
receive() – přijímá zprávu z určeného zdrojového místa;
pokud není zpráva dostupná, je proces blokován (příp. pokračuje s
chybovým kódem)
A7B38UOS Úvod do operačních systémů 07 - IPC
IPC: Sdílená paměť (Shared Memory)
Metoda IPC kdy jeden proces alokuje prostor v paměti a další do něho
mohou přistupovat.
Využívá se v Unixových systémech, je definována v POSIXu.
A7B38UOS Úvod do operačních systémů 07 - IPC
Příklady meziprocesové komunikace
Nezávislé na platformě:
ƒ Roury (pipes)
ƒ Schránky (sockets)
ƒ Semafory
Závislé na platformě:
ƒ Signály (typicky v Unixu)
ƒ Fronty zpráv
ƒ Sdílená paměť
ƒ Zasílání zpráv
ƒ Paměťově mapované soubory
ƒ aj.
A7B38UOS Úvod do operačních systémů 07 - IPC
Příklady meziprocesové komunikace v OS Unix
Signály
Viz další presentace.
A7B38UOS Úvod do operačních systémů 07 - IPC
Problémy při synchronizaci procesů/vláken
Uváznutí (Deadlock) a vyhladovění (Starvation)
Uváznutí (též zablokování):
Proces/vlákno nebo množina procesů/vláken čeká na událost, kterou
může generovat pouze jiný proces/vlákno z této množiny.
Příklad: inverze priorit
Vyhladovění (též stárnutí):
procesu/vláknu jsou trvale odpírány požadované sdílené prostředky
bez kterých nemůže dokončit úlohu.
A7B38UOS Úvod do operačních systémů 07 - IPC
Uváznutí – formální model
proces
prostředek
Potenciální deadlock
A7B38UOS Úvod do operačních systémů 07 - IPC
Uváznutí (Deadlock)
Podmínky uváznutí (Coffmanovy podmínky):
k uváznutí dojde pokud jsou splněny následující 4 podmínky:
ƒ výlučný přístup (Exclusive use): prostředek přidělen výhradně
jednomu procesu
ƒ neodnímatelnost (No preemption): prostředek přidělený procesu
nemůže být násilně odebrán
ƒ podmínka „drž a čekej“ (Hold and wait): proces, který má již
přiděleny nějaké prostředky, může žádat o další prostředky
ƒ cyklické čekání (Cyclic dependency): existuje smyčka (dvou nebo
více procesů) kde každý proces čeká na prostředek přidělený
následujícímu procesu ve smyčce
A7B38UOS Úvod do operačních systémů 07 - IPC
Řešení problému uváznutí
ƒ Prevence (deadlock prevention): napadení jedné z
Coffmanových podmínek;
ƒ Vyhnutí se uváznutí (deadlock avoidance): pečlivá alokace
prostředků; přidělení pokud je to bezpečné (např. „Bankéřův
algoritmus“);
ƒ Detekce uváznutí a zotavení (deadlock detection & recovery):
řešení problému když nastane, pak zotavení;
ƒ Pštrosí algoritmus: předstíráme, že problém neexistuje; problém
vyřeší uživatel/administrátor („kill“).
A7B38UOS Úvod do operačních systémů 07 - IPC
Klasické problémy synchronizace mezi procesy
Problém producent-konzument (Producer-Consumer Problem)
ƒ jeden proces (=producent) poskytuje data a ukládá je do sdílené
paměti
ƒ druhý proces (=konzument) data ze sdílené paměti odebírá
Blokování pokud:
ƒ producent vkládá do plného bufferu
ƒ konzument odebírá z prázdného bufferu
A7B38UOS Úvod do operačních systémů 07 - IPC
Problém producent – konzument 1
Viz [1]
A7B38UOS Úvod do operačních systémů 07 - IPC
Problém producent – konzument 2 (viz [3])
define N 100
int count = 0;
/* number of slots in buffer */
/* number of items in buffer */
void producer(void)
{ int item;
while(TRUE) {
item = produce_item();
if (count == N) sleep();
/* if buffer is full, go to sleep */
insert_item(item);
count = count + 1;
if (count == 1) wakeup(consumer); /* was buffer empty? */
}
}
A7B38UOS Úvod do operačních systémů 07 - IPC
Problém producent – konzument 3
void consumer(void)
{ int item;
while (TRUE) {
if (count == 0)
/* critical point for context switching */
sleep();
/* if buffer is empty, go to sleep */
item=remove_item()
count = count – 1;
if (count == N - 1) wakeup(producer);
/* was buffer full? */
consume_item(item);
}
}
Toto je špatné řešení !!! Může dojít k chybě souběhu.
A7B38UOS Úvod do operačních systémů 07 - IPC
Problém producent – konzument: použití semaforů (viz [3])
#define N 100
typedef int semaphore;
semaphore mutex = 1;
semaphore empty = N;
semaphore full = 0;
/* number of slots in buffer */
/* control access to critical section (CS)*/
/* counts empty buffer slots*/
/* counts full buffer slots*/
void producer(void) {
itemtype item;
while (TRUE) {
item=produce_item();
down(&empty);
down(&mutex); /* enter CS*/
insert_item(item);
up(&mutex); /* leave CS*/
up(&full);
}
}
A7B38UOS Úvod do operačních systémů 07 - IPC
void consumer(void) {
itemtype item;
while (TRUE) {
down(&full);
down(&mutex); /* enter CS */
item=remove_item();
up(&mutex); /* leave CS */
up(&empty);
consume_item(item);
}
}
Problém čtenáři – písař
Více procesů/vláken, v roli čtenáře nebo písaře, musí přistupovat ke sdílené
paměti, aby do ní zapisovaly nebo z ní četly. Přitom je potřeba zaručit integritu
dat, která může být porušena souběhem čtenáře a písaře nebo dvou písařů.
Praktický příklad: rezervační systém letenek
A7B38UOS Úvod do operačních systémů 07 - IPC
Problém čtenáři – písař (korektní řešení) (viz [3])
int rc = 0;
semaphore mutex = 1;
semaphore db = 1;
/* readers counter */
/* controls access to ‘rc’ */
/* access to database */
void reader(void) {
while(TRUE){
down(&mutex);
rc = rc + 1;
if (rc == 1) down(&db);
up(&mutex);
read_data_base();
down(&mutex);
rc = rc - 1;
if (rc == 0) up(&db);
up(&mutex);
use_data_read();
}
}
A7B38UOS Úvod do operačních systémů 07 - IPC
void writer(void) {
while(TRUE) {
think_up_data();
down(&db);
write_data_data();
up(&db);
}
}
Problém večeřící filosofové
Problém procesů, které soutěží o výlučný přístup k omezenému počtu
prostředků.
Zadání:
N filozofů sedí kolem kulatého stolu a každý z nich buď přemýšlí nebo jí.
K jídlu potřebují současně levou a pravou vidličku.
A7B38UOS Úvod do operačních systémů 07 - IPC
Problém večeřící filosofové – jednoduché ale špatné řešení
void philosopher() {
while(1) {
sleep();
get_left_fork();
get_right_fork();
eat();
put_left_fork();
put_right_fork();
}
}
A7B38UOS Úvod do operačních systémů 07 - IPC
Problém večeřící filosofové – řešení (viz [3])
#define N 5 /* Number of philosphers */
#define LEFT ((i+N-1) % N)
#define RIGHT ((i+1) % N)
typedef enum { thinking, hungry, eating } stat;
stat state[N];
semaphore mutex=1;
semaphore s[N]; /* one per philosopher,
initially set to 0 */
void philosopher(int process) {
while (TRUE) {
think();
take_forks(process);
eat();
put_forks(process);
}
}
A7B38UOS Úvod do operačních systémů 07 - IPC
void take_forks(int i) {
down(&mutex);
state[i] = hungry;
test(i);
up(&mutex);
down(&s[i]);
}
void put_forks(int i)
{
down(&mutex);
state[i] = thinking;
test(LEFT(i));
test(RIGHT(i));
up(&mutex);
}
void test(int i)
{
if (state[i] == hungry &&
state[LEFT(i)] != eating &&
state[RIGHT(i)] != eating)
{
state[i] = eating;
up(&s[i]);
}
}
ÚVOD DO OPERAČNÍCH SYSTÉMŮ
KONEC 6. přednášky
České vysoké učení technické Fakulta elektrotechnická
A7B38UOS Úvod do operačních systémů 07 - IPC