Semafory Zobecněním operací WAKEUP a SLEEP přidáním celočíselného čítače vzniknou semafory a jejich atomické operace DOWN a UP.

Transkript

1 Semafory Zobecněním operací WAKEUP a SLEEP přidáním celočíselného čítače vzniknou semafory a jejich atomické operace DOWN a UP. Dvě sémantiky vzhledem k hodnotám čítače: 1. čítač >= 0 Operace DOWN zkontroluje hodnotu semaforu. Jestliže je větší než 0, sníží hodnotu semaforu o 1 a operace skončí. Jestliže je rovna 0, operace DOWN se zablokuje a příslušný proces je přidán do fronty čekajících procesů na daném semaforu. Operace UP zjistí, zda je fronta čekajících procesů na daném semaforu neprázdná. Pokud ano, vybere jeden z čekajících procesů (např. nejdéle čekající) a ten odblokuje (tj. pokračuje za svou operací DOWN). Pokud je fronta prázdná, zvětší čítač semaforu o čítač libovolný (záporná hodnota je počet zablokovaných procesů) Operace DOWN sníží hodnotu semaforu o 1. Jestliže je větší nebo roven 0, operace skončí. Jestliže je menší než 0, operace DOWN se zablokuje a příslušný proces je přidán do fronty čekajících procesů na daném semaforu. Operace UP zvětší čítač semaforu o 1. Pokud je hodnota menší rovna 0, zkontroluje, zda je fronta čekajících procesů na daném semaforu neprázdná. Pokud ano, vybere jeden z čekajících procesů a ten odblokuje. Binární semafory nabývají pouze hodnot 0 a 1. Dá se jimi snadno vytvořit kritická sekce "uzávorkovaná" mezi operace DOWN a UP příslušného semaforu.

2 Monitory Pro zjednodušení práce a zamezení chyb při použití semaforů bylo navrženo synchronizační primitivum monitor. Monitor je soubor funkcí, proměnných a datových struktur, který jsou sdružen do zvláštního balíku. Procesy smí volat funkce z monitoru, kdykoliv chtějí, ale nemají přístup k proměnným monitoru z funkcí mimo monitor. Navíc monitor zaručuje, že v jednom okamžiku může být aktivní nejvýše jeden proces v jedné instanci monitoru. Monitor je konstrukcí programovacího jazyka a překladač tudíž ví, že funkce monitoru je třeba překládat jinak. Záleží na překladači, jak implementuje monitory (typicky pomocí semaforů). Protože vzájemné vyloučení zařizuje překladač a ne programátor, zabrání se mnoha chybám. Stačí pouze vědět, že všechny kritické operace je třeba provádět v monitorech. Blokování procesů uvnitř funkcí monitoru pomocí podmíněných proměnných a operacemi WAIT a SIGNAL na nich definovaných. Podmíněné proměnné nejsou čítače (na rozdíl od semaforů). Když funkce monitoru zjistí, že nemůže pokračovat, volá operaci WAIT a zablokuje aktivní proces v monitoru. To umožní jinému procesu vniknout do monitoru. Jiný proces může být probuzen pomocí operace SIGNAL (jeden z čekajících z množiny zablokovaných procesů na dané podmíněné proměnné). Tady ale vzniká problém, že v jednom okamžiku jsou dva procesy v jedné instanci monitoru. Existují dvě řešení: 1. Spustit probuzený proces a druhý uspat 2. Proces volající SIGNAL okamžitě opustí monitor.

3 Zprávy Systémová volání SEND a RECEIVE pro zasílání a příjem zpráv. Zpráva je nějaká přenášená informace mezi odesilatelem a příjemcem. SEND zašle zprávu. Nikdy se nezablokuje. Pokud na zprávu čeká příjemce operací RECEIVE, je mu zpráva doručena a příjemce odblokován. RECEIVE zprávu přijímá. Pokud žádná zpráva není dostupná, přijímající proces je zablokován. Je třeba vyřešit problém adresace, tj. určení odesilatele a příjemce. Lze řešit např. identifikací procesu na daném počítači. Jiným řešením je zavedení schránek (mailboxů) a adresace pomocí identifikace schránky. Schránka je vyrovnávací paměť typicky pevné délky. Do ní jsou zprávy ukládány operací SEND a z ní vybírány operací RECEIVE. Schránka modifikuje operaci SEND: pokud je schránka plná, zablokuje se i SEND. Zajímavým případem je situace, kdy je schránka nulové velikosti. Pokud je odesilatelem proveden SEND a ještě tam není žádný příjemce čekající operací RECEIVE, musí odesilatel počkat. Podobně příjemce čeká na odesilatele, až něco zašle. Po předání zprávy, tj. je provedena operace SEND i RECEIVE na jednu schránku, se oba procesy opět rozběhnou. Tento případ se nazývá dostaveníčko (randezvous).

4 Ekvivalence primitiv Semafory, monitory a zprávy jsou vzájemně ekvivalentní. Implementace semaforů pomocí zpráv pomocí synchronizačního procesu - serveru semaforů. Problém obědvajících filozofů Pět filozofů sedí kolem kulatého stolu. Každý filozof má talíř špaget. U každého talíře je jedna vidlička. Špagety jsou tak slizké, že je k jídlu zapotřebí dvou vidliček. Život filozofů sestává ze střídajících se období jídla a přemýšlení. Když filozof dostane hlad, pokusí se vzít v libovolném pořadí dvě vidličky přilehlé k jeho talíři. Pokud se mu to podaří, chvilku jí, a pak zase vidličky v libovolném pořadí odloží. Napište program, který simuluje život filozofa.

5 #define N 5 /* počet filozofů */ void philosopher(int i)/* i: který filozof (0 až N-1) */ for(;;) think(); /* filozof myslí */ take_fork(i); /* vezmi levou vidličku */ take_fork((i+1) % N); /* vezmi pravou vidličku */ eat(); /* hurá na špagety */ put_fork(i); /* odlož levou vidličku */ put_fork((i+1) % N); /* odlož pravou vidličku */ Funkce take_fork vezme vidličku se zablokováním, pokud není dostupná. Pokud ji ale všech pět filozofů uchopí ve stejném okamžiku, všichni se zablokují čekáním na druhou. Je to špatně!!! Modifikace: filozof se uchopí levou vidličku a podívá se, jestli je pravá vidlička volná. Pokud není, položím zpět levou vidličku. Tato modifikace vede ke stavu nazvaném vyhladovění (starvation) - program není zablokovaný, ale nedělá, co by měl. Problém ospalého holiče Holičství má jednoho holiče, jedno holičské křeslo a N křesel pro čekající zákazníky. Jestliže není přítomen žádný zákazník, holič se posadí a spí. Když přijde zákazník, tak probudí holiče a jde si sednou do holičského křesla. Jestliže přijdou další zákaznící a holič už stříhá, tak si sedají do křesel pro zákazníky. Pokud už není žádné volné křeslo pro zákazníky, zákazník odejde. Napište program, který simuluje holiče a zákazníky.

6 Problém producent/konzument se semafory #define N 100 /* velikost bufferu */ semaphore mutex = 1;/* řídí přístup do kritické sekce */ semaphore empty = N;/* počet volných položek v bufferu */ semaphore full = 0;/* počet užitých položek bufferu */ void producer(void) int item; for(;;) produce_item(&item);/* připrav další prvek */ down(&empty); /* sniž čítač volných položek */ down(&mutex); /* vstup do kritické sekce */ enter_item(item); /* ulož nový prvek do bufferu */ up(&mutex); /* opusť kritickou sekci */ up(&full); /* zvětši počet užitých položek */ void consumer(void) int item; for(;;) down(&full); /* sniž čítač užitých položek */ down(&mutex); /* vstup do kritické sekce */ remove_item(&item);/* načti další prvek z bufferu */ up(&mutex); /* opusť kritickou sekci */ up(&empty); /* zvětši počet volných položek */ consume_item(item);/* zpracuj prvek */

7 Problém producent/konzument s monitory monitor ProducerConsumer condition full, empty; integer count; procedure enter; if count = N then wait(full); enter_item; count := count + 1; if count = 1 then signal(empty); end; procedure remove; if count = 0 then wait(empty); remove_item; count := count - 1; if count = N-1 then signal(full); end; count := 0; end monitor; procedure producer; while true do produce_item; ProducerConsumer.enter; end end; procedure consumer; while true do ProducerConsumer.remove; consume_item; end end;

8 Problém producent/konzument se zprávami Předpokládáme, že všechny zaslané a ještě nepřijaté zprávy jsou meziukládány systémem. #define N 100 /* počet položek bufferu */ void producer(void) int item; message m; for(;;) produce_item(&item); receive(consumer, &m); /* čekej na příchod díry */ build_message(&m, item); /* vytvoř zprávu */ send(consumer, &m); /* vyšli prvek */ void consumer(void) int item, i; message m; for(i=0;i<n;i++) send(producer, &m); /* vyšli N děr */ for(;;) receive(producer, &m); /* čekej na příchod prvku */ extract_item(&m, &item); /* vyber prvek */ send(producer, &m); /* vyšli díru */ consume_item(item);

9 Problém obědvajících filozofů se semafory #define N 5 /* počet filozofů */ #define LEFT (i-1)%n /* číslo levého souseda i */ #define RIGHT (i+1)%n/* číslo pravého souseda i*/ enum THINKING, HUNGRY, EATING state[n]; semaphore mutex = 1; semaphore s[n]; void test(int i) if(state[i]==hungry && state[left]!=eating && state[right]!=eating) state[i] = EATING; up(s[i]); void take_forks(int i) down(mutex); /* vstup do kritické sekce */ state[i] = HUNGRY; /* filozof i má hlad */ test(i); /* zkus získat dvě vidličky */ up(mutex); /* odchod z kritické sekce */ down(s[i]); /* při nezískání vidliček se blokuje */ void put_forks(int i) down(mutex); /* vstup do kritické sekce */ state[i] = THINKING; /* filozof dojedl */ test(left); /* zjisti, zda levý soused může jíst */ test(right); /* zjisti, zda pravý soused může jíst */ up(mutex); /* opusť kritickou sekci */

10 void philosopher(int i) for(;;) think(); take_forks(i); /* vezmi dvě vidličky */ eat(); put_forks(i); /* odlož obě vidličky */ Problém ospalého holiče #define CHAIRS 5 /* počet volných křesel */ int waiting = 0; /* počet čekajících zákazníků */ void barber(void) for(;;) receive(customer);/* je někdo připraven na holení */ waiting--; /* počet čekajících se sníží */ send(customer); /* pozvu ho do holičského křesla */ cut_hair(); void customer(void) if(waiting<chairs) /* ještě je tu volné křeslo */ waiting++; /* zvyšuje se počet čekajících */ send(barber); /* probuď holiče */ receive(barber); /* došla na mě řada */ get_haircut();