Stáhnout prezentaci
Prezentace se nahrává, počkejte prosím
ZveřejnilJiří Vaněk
1
Operační systémy Přednášky pro výuku předmětu Operační systémy Ing. Antonín Vaněk, CSc. DFJP, Univerzita Pardubice září 2003
2
Kapitola 5 Konkurence procesů: vzájemné vylučování a synchronizace
3
Konkurence procesy si konkurují při: sdílení prostředků alokaci času procesoru komunikaci procesů synchronizaci více procesů
4
Interakce procesů procesy nevědí jeden o druhém interakce neexistuje procesy o sobě vědí jen nepřímo interakci zprostředkuje OS nebo jiný program procesy o sobě vědí přímo je možná přímá interakce
5
Zájmová sféra OS sledování aktivity procesů alokace a dealokace prostředků čas procesoru paměť I/O zařízení soubory ochrana dat a prostředků výsledek procesu nesmí záviset na rychlosti provádění... sdílí s ostatními procesy čas procesoru
6
Soutěžení procesů o prostředky provádění jednoho procesu může ovlivnit chování soupeřících procesů pokud přístup k jednomu prostředku požaduje více procesů současně, lze prostředek přidělit jen jednomu z nich ostatní procesy musí čekat ! nelze vždy zaručit, že blokovaný proces získá přístup k prostředku v budoucnosti takový proces nikdy neskončí, bude bez omezení čekat !
7
Problémy s konkurencí pokud přístup ke sdíleným prostředkům není řízen, může dojít k porušení konzistence dat výsledek akcí prováděných procesy může být závislý na pořadí, v jakém procesy dostanou přidělen procesor přístup ke sdíleným prostředkům je nutno řídit ! To je nepřípustné!
8
Příklad procesy P1 a P2 mají přístup ke stejné proměnné a a provádějí stejnou proceduru echo procesy mohou být kdykoliv (a tedy kdekoliv) přerušeny pokud je P1 po provedení operace vstupu přerušen, pak se provede P2 a nakonec se dokončí P1... ... proces P1 vypíše znak, načtený procesem P2 !! static char a; void echo() { cin >> a; cout << a; }
9
Problémy s řízením přístupu vzájemné vylučování (Mutual Exclusion) v každém okamžiku smí mít přistup k prostředku pouze jeden proces smrtící objetí (Deadlock) procesy vzájemně čekají na uvolnění prostředků, přidělených jiným procesům vyhladovění (Starvation) proces nemůže získat přístup k požadovanému prostředku v důsledku obsazení prostředku jinými procesy
10
Kooperace procesů sdílením procesy používají a mění sdílená data sdílené proměnné, soubory, databáze... v daném čase může data měnit pouze jeden proces např. textový soubor nesmí být otevřen pro zápis více editory současně k zajištění integrity dat se používají kritické sekce
11
Kooperace procesů komunikací vzájemná komunikace procesům umožňuje synchronizovat (koordinovat) různé aktivity může nastat smrtící objetí každý proces čeká na zprávu od některého jiného procesu ... žádný z procesů nemůže pokračovat může nastat vyhladovění dva procesy si stále vyměňují zprávy, zatímco jiný proces čeká na zprávu ... nikdy se jí nedočká
12
Kritická sekce proces je ve (své) kritické sekci (pro daný sdílený prostředek), jestliže provádí část programu, manipulující s (tímto) sdíleným prostředkem provádění kritické sekce musí být vzájemně výlučné (mutually exclusive) to platí i pro multiprocesorové prostředí každý proces musí žádat o povolení ke vstupu do kritické sekce ! v každém okamžiku smí být v kritické sekci (pro daný prostředek) pouze jeden proces
13
Obecná struktura procesu část programu, implementující protokol povolení přístupu, nazýváme vstupní sekce po vlastní kritické sekci (tj. úseku, kde dochází k vlastní manipulaci se sdíleným prostředkem) může následovat výstupní sekce zbytek kódu se označuje jako zbytková sekce repeat entry section critical section exit section remainder section forever
14
Rámec pro řešení procesy se provádějí nenulovou rychlostí nedělají se žádné zvláštní předpoklady o relativní rychlosti procesů může být použito i více procesorů, ale hardware paměti nesmí umožňovat současný přístup procesorů k jednomu paměťovému místu nedělají se žádné zvláštní předpoklady o prokládaném provádění stačí specifikovat vstupní a výstupní sekci
15
Požadované vlastnosti vzájemné vylučování (Mutual Exclusion) v kterémkoliv okamžiku může být v kritické sekci nejvýše jeden proces pokrok v přidělování pokud žádný proces není v kritické sekci a některé procesy tam chtějí vstoupit, na rozhodování o tom, který proces dostane povolení, se mohou podílet pouze procesy, které se nenacházejí ve zbytkové sekci toto rozhodování se musí uskutečnit v konečném čase omezené čekání poté, co proces požádal o přístup, smí před ním získat přístup pouze omezený počet procesů jinak by hrozilo vyhladovění
16
Typy řešení SW řešení algoritmy, jejichž korektnost nezávisí na dalších předpokladech (viz Rámec řešení) HW řešení využívá speciální instrukce procesoru OS řešení poskytuje programátorovi vhodné funkce a datové struktury
17
SW řešení: aktivní čekání Příklad: svého šamana (kritickou sekci) může v daném čase navštívit pouze jediný eskymák (proces) Igloo má malý vchod, takže dovnitř může vstoupit vždy jen jeden eskymák, aby si přečetl jméno napsané na tabuli Pokud je na tabuli jeho jméno, může jít k šamanovi Pokud je na tabuli napsáno jiné jméno, eskymák igloo opět opustí a čeká Čas od času eskymák znovu vstoupí do igloo podívat se na tabuli
18
SW řešení nejprve předpokládejme 2 procesy algoritmy 1 a 2 jsou nesprávné správný je algoritmus 3 (Petersonův) potom řešení zobecníme pro n procesů tzv. bakery algorithm nejprve pro 2 procesy: P0 a P1 když uvažujeme proces Pi, proces Pj vždy představuje ostatní procesy (i != j)
19
Algoritmus 1 sdílená proměnná turn je inicializována (na 0 nebo 1) před provedením libovolného procesu Pi kritická sekce CS procesu Pi se provádí, jestliže je turn = i Pi aktivně čeká (busy waiting) pokud je Pj v kritické sekci: požadavek na vzájemné vylučování je splněn požadavek pokroku není splněn, protože algoritmus vyžaduje přesné dodržení alternace kritických sekcí Process Pi: repeat while(turn!=i){}; CS turn:=j; RS forever
20
Algoritmus 1 - test příklad: předpokládejme, že P 0 má dlouhou zbytkovou sekci RS, P 1 krátkou pokud je turn=0, P 0 vstoupí do CS a pak provádí dlouhou RS (turn=1) zatím P 1 vstoupí do CS, provede krátkou RS (turn=0) a znovu se pokusí vstoupit do CS – ale požadavek je odmítnut ! P 1 musí čekat, dokud P 0 nedokončí RS
21
jedna booleovská proměnná flag pro každý proces: flag[0] a flag[1] signalizace připravenosti ke vstupu do CS nastavením flag[i]:=true požadavek na vzájemné vylučování je splněn požadavek na pokrok splněn není po sekvenci: P1: flag[1]:=true P0: flag[0]:=true budou oba procesy neomezeně čekat – máme deadlock Process Pi: repeat flag[i]:= true; while(flag[j]){}; CS flag[i]:= false; RS forever Algoritmus 2
22
Algoritmus 3 (Petersonův) Inicializace: flag[0]:=flag[1]:=false turn:= 0 nebo 1 signalizace připravenosti ke vstupu do CS nastavením flag[i]:=true Pokud se oba procesy pokusí vstoupit do CS současně, pouze jeden bude mít potřebnou hodnotu proměnné turn výstupní sekce: specifikuje, že Pi nechce vstoupit do sekce CS Process Pi: repeat flag[i]:=true; turn:=j; do {} while (flag[j]and turn=j); CS flag[i]:=false; RS forever
23
Algoritmus 3 – analýza správnosti požadavek na vzájemné vylučování je splněn není možné, aby P 0 a P 1 byly oba v CS nemůže nastat flag[0] = flag[1] = true a turn = i pro každý proces Pi plnění požadavků na pokrok a omezenost čekání Pi nemůže vstoupit do CS, pokud není současně flag[ j] = true a turn = j pokud Pj není připraven ke vstupu do CS, je flag[ j] = false a Pi proto může vstoupit do CS
24
pokud Pj nastavil flag[ j]=true a je ve while(), pak je buďto turn=i nebo turn=j je-li turn=i, pak Pi nevstupuje do CS (na řadě je Pj) ; pokud turn=j, pak Pj vstupuje do CS, ale při výstupu z CS nastaví flag[ j]=false a tím dovolí Pi vstoupit do CS když Pj nastavuje flag[ j]=true, nastavil již turn=i protože Pi po dobu čekání ve while() nemění nastavení turn, nemůže Pi vstoupit do CS, dokud nevstoupí do CS alespoň jednou také Pj (omezené čekání) Algoritmus 3 – analýza správnosti
25
Vliv chyb programu pokud jsou splněna všechna 3 kriteria (vzájemné vylučování, pokrok a omezené čekání), pak je řešení odolné proti chybám ve zbytkové sekci (RS) protože chyba v RS je vlastně totéž, co neomezeně dlouhá sekce RS bohužel řešení nemůže zajistit odolnost proti chybám v kritické sekci (CS) proces Pi, u kterého dojde k chybě v CS, signalizuje ostatním procesům tento fakt – Pi je pro tyto procesy stále v kritické sekci
26
Řešení pro n procesů t.zv. Bakery algoritmus před vstupem do kritické sekce dostane každý proces číslo. Držitel nejmenšího čísla může vstoupit do CS když Pi a Pj dostanou stejná čísla: pokud je i<j, má přednost Pi, jinak Pj ve výstupní sekci nastaví proces Pi přidělené číslo na 0
27
Bakery algoritmus poznámky k zápisu: (a,b) < (c,d) když a < c nebo když a = c a b < d max(a 0,...a k ) je číslo b takové, že platí b >= a i pro i=0..k sdílená data: choosing: array[0..n-1] of boolean; všechny prvky pole inicializovány na false number: array[0..n-1] of integer; všechny prvky pole inicializovány na 0 korektnost programu závisí na následujícím faktu: jestliže je Pi v CS a Pk si právě vybral své číslo number[k] != 0, pak (number[i],i) < (number[k],k) ale důkaz je poněkud složitý...
28
Process Pi: repeat choosing[i]:=true; number[i]:= max(number[0]..number[n-1])+1; choosing[i]:=false; for j:=0 to n-1 do { while (choosing[j]) {}; while (number[j]!=0 and (number[j],j)<(number[i],i)){}; } CS number[i]:=0; RS forever Bakery algoritmus
29
Nedostatky SW řešení Procesy požadující přístup do kritické sekce jsou v aktivním čekání (busy waiting) a proto zbytečně spotřebovávají čas procesoru pokud jsou kritické sekce dlouhé, může být efektivnější čekající procesy blokovat...
30
HW řešení opírá se o některé základní principy: proces běží v procesoru kontinuálně, dokud nevyvolá službu OS nebo není přerušen k přerušení procesu může dojít pouze na hranicích instrukcí mezi dokončením jedné a zahájením další instrukce přístup k paměťovému místu obvykle vylučuje současný přístup ostatních procesů k tomuto místu
31
Zákaz přerušení proces běží, dokud nevyvolá službu OS nebo není přerušen u jednoprocesorového systému zákaz přerušení zaručuje vzájemné vylučování u víceprocesorových systémů nezaručuje jsou omezeny možnosti procesoru prokládat programy zákaz přerušení může významně snížit efektivnost provádění programů v době, kdy je některý proces v kritické sekci, nelze procesor přidělit jinému procesu obecně nevhodné řešení prodlužuje se doba latence systému vadí tam, kde je požadována rychlá reakce (multimedia, RT systémy)
32
Process Pi: repeat disable interrupts CS enable interrupts RS forever Zákaz přerušení
33
Speciální instrukce přístup k paměťovému místu obvykle vylučuje přístup ostatních procesů k tomuto místu lze navrhnout instrukci procesoru, která provádí dvě akce (např. čtení a zápis) s jedním paměťovým místem jako atomickou (nedělitelnou) operaci provedení takové instrukce nelze přerušit a proto zaručuje vzájemné vylučování dokonce i při použití více procesorů takovou instrukci lze velmi jednoduše použít pro řešení problému vzájemného vylučování ... ale pro řešení dalších problémů kritické sekce (pokrok, omezené čekání) je nutné použít složitější programové konstrukce
34
Instrukce test-and-set jediná instrukce procesoru přečte příznak a současně ho nastaví pokud byl příznak nastaven už před provedením instrukce, nové nastavení nic nezmění kritická sekce je obsazena a proces proto musí čekat ... pokud ale příznak nastaven nebyl, může proces vstoupit do kritické sekce instrukce je nepřerušitelná a proto nemůže dojít k chybnému vyhodnocení příznaku lze použít u jedno- i víceprocesorových systémů lze použít pro více kritických sekcí
35
Instrukce test-and-set popis instrukce test-and-set v jazyce C++: bool testset(int& i) { if (i==0) { i=1; return true; } else { return false; }
36
Instrukce test-and-set Nevýhody jedná se o aktivní čekání, zabírající čas procesoru může dojít k vyhladovění když proces uvolní kritickou sekci, jako další získá povolení proces, který první provede instrukci v systému může vzniknout deadlock proces s nízkou prioritou má kritickou sekci, proces s vysokou prioritou žádá o povolení procesor je přidělen procesu s vysokou prioritou, kde pak čeká na uvolnění ale k tomu nemůže dojít, protože proces s nízkou prioritou nemůže získat procesor
37
algoritmus přístupu ke kritické sekci, vyžívající funkci testset sdílená proměnná b se inicializuje na 0 pouze první proces Pi (který nastaví b) vstupuje do kritické sekce Process Pi: repeat repeat{} until testset(b); CS b:=0; RS forever Instrukce test-and-set
38
Instrukce xchg instrukce xchg je dostupná u platformy Intel 86 sdílená proměnná b se inicializuje na 0 každý proces Pi má lokální proměnnou k do CS může vstoupit pouze proces, který najde b=0 tento proces Pi vyloučí přístup ostatních procesů Pj nastavením b=1 Process Pi: repeat k:=1 repeat xchg(k,b) until k=0; CS b:=0; RS forever
39
OS řešení: semafory synchronizační nástroj, nevyžadující aktivní čekání semafory poskytuje programům OS semafor je celočíselná proměnná, která je (s výjimkou inicializace) dostupná pouze prostřednictvím dvou atomických operací: wait(S) signal(S) aby se vyloučilo aktivní čekání, je proces, který musí čekat, blokován a zařazen do fronty procesů, čekajících na stejnou událost změnu stavu příslušného semaforu
40
Semafory ve skutečnosti je tedy semafor datovou strukturou typu záznam: type semaphore = record count: integer; queue: list of process end; var S: semaphore; když proces musí čekat na semafor S, je blokován a zařazen do fronty tohoto semaforu operce signal odstraní jeden proces z fronty a přesune ho do seznamu procesů připravených ke spuštění způsob výběru procesu určuje zvolená strategie, např. FIFO
41
Operace semaforu wait(S): S.count--; if (S.count<0) { block this process place this process in S.queue } signal(S): S.count++; if (S.count<=0) { remove a process P from S.queue place this process P on ready list } proměnnou count je nutné inicializovat na nezápornou hodnotu (aktuální hodnota závisí na potřebách aplikace)
42
Semafory: pozorování Když je S.count >=0, je počet procesů, které mohou provést wait(S) bez blokování roven S.count Když je S.count<0, je počet procesů čekajících na semafor S roven |S.count| Atomicita a vzájemné vylučování: žádné dva procesy nemohou být ve wait(S) a signal(S) (na tentýž S) ve stejném čase (platí i pro více procesorů) programové bloky definující wait(S) a signal(S) jsou ve skutečnosti kritické sekce
43
Semafory: pozorování kritické sekce definované ve wait(S) a signal(S) jsou velmi krátké typicky 10 instrukcí řešení: jednoprocesorové: zákaz přerušení po dobu provádění operace je to velmi krátká doba nelze použít u víceprocesorového systému víceprocesorové: použít některé z popsaných SW nebo HW řešení rozsah aktivního čekání nsmí být velký
44
Použití semaforů pro řešení problému kritické sekce Pro n procesů inicializuj S.count na 1 pak má pouze 1 proces povoleno vstoupit do CS (vzájemné vylučování) obecně platí, že inicializuj S.count na k lze povolit vstup do CS současně k procesům Process Pi: repeat wait(S); CS signal(S); RS forever
45
Použití semaforů pro synchronizaci procesů máme dva procesy: P1 a P2 příkaz S1 v P1 musí být proveden dříve než příkaz S2 v P2 definujeme semafor synch inicializujeme synch na 0 správnou synchronizaci zajistíme takto: P1: S1; signal(synch); P2: wait(synch); S2;
46
Binární semafory semafory, které jsme zatím používali, nazýváme čítací nebo celočíselné semafory (counting semaphores, integer semaphores) můžeme však použít i binární semafory podobné čítacím semaforům, pouze proměnná ”count” je typu boolean čítací semafory lze implementovat pomocí binárních semaforů... použití binárních semaforů je obvykle náročnější než čítacích např. je nelze inicializovat na hodnotu k > 1
47
Binární semafory waitB(S): if (S.value = 1) { S.value := 0; } else { block this process place this process in S.queue } signalB(S): if (S.queue is empty) { S.value := 1; } else { remove a process P from S.queue place this process P on ready list }
48
Spinlocks čítací semafory, používající aktivní čekání (busy waiting) místo blokování (blocking) jsou užitečné u víceprocesorových systémů, pokud kritická sekce netrvá dlouho aktivním čekáním sice ztratíme malé množství času CPU, ale ušetříme tím čas potřebný pro přepnutí procesů wait(S): S--; while S<0 do{}; signal(S): S++;
49
Problémy se semafory semafory jsou výkonným nástrojem pro řešení vzájemného vylučování a koordinace procesů wait(S) a signal(S) jsou rozděleny do více procesů a proto je obtížné porozumět jejich působení použití musí být korektní ve všech procesech jediný chybný proces může způsobit problémy s celým souborem procesů
50
Problém obědvajících filozofů 5 filozofů u stolu pouze jí nebo přemýšlí při jídle každý potřebuje 2 vidličky k dispozici je pouze 5 vidliček ilustruje obtížnost alokace prostředků procesům bez vzájemného zablokování či vyhladovění (deadlock, starvation) klasický synchronizační problém
51
Problém obědvajících filozofů každý filozof představuje jeden proces potřebujeme jeden semafor pro každou vidličku: fork: array[0..4] of semaphores Initialization: fork[i].count:=1 for i:=0..4 Process Pi: repeat think; wait(fork[i]); wait(fork[i+1 mod 5]); eat; signal(fork[i+1 mod 5]); signal(fork[i]); forever první pokus: když každý filozof začne tím, že uchopí vidličku po své levici, nastává deadlock
52
řešení: dovolit začít jíst pouze 4 filozofům najednou pak vždy alespoň 1 filozof může jíst, zatímco zbývající 3 musí čekat (s jednou vidličkou v ruce) musíme tedy použít další semafor (např. T), který umožní omezit počet filozofů Inicializace: T.count:=4 Process Pi: repeat think; wait(T); wait(fork[i]); wait(fork[i+1 mod 5]); eat; signal(fork[i+1 mod 5]); signal(fork[i]); signal(T); forever Problém obědvajících filozofů
53
Problém producenta a konzumenta dva typy procesů: producenti (producers) konzumenti (consumers) jeden nebo několik producentů produkuje data, která spotřebovává jeden nebo více konzumentů např. programy produkují znaky, které pak jsou spotřebovány (vytištěny) tiskárnou aby nevznikaly zbytečné čekací doby, je nutné zavést pro přechodné uskladnění produkovaných dat mezisklad - vyrovnávací paměť (buffer) pro řízení lze použít dva semafory jeden reprezentuje počet výrobků ve skladě druhý signalizuje, zda lze vstoupit do skladu
54
Nekonečná vyrovnávací paměť b[2]b[3]b[4] outin b[1]b[5].. šedá oblast indikuje, která část bufferu je obsazena vyrovnávací paměť (buffer) je pole, do kterého lze ukládat produkovaná data paměť musí mít nezávislý přístup pro zápis a čtení (unbounded buffer) in ukazuje na položku, do které se bude vkládat nový produkt out ukazuje na položku, která bude konzumována
55
Funkce producenta producer: repeat produce item v; b[in] := v; in := in + 1 forever;
56
Funkce konzumenta consumer: repeat while in <= out do { nothing }; w := b[out]; out := out + 1; consume item w forever;
57
Kruhová vyrovnávací paměť out in b[1]b[5] šedá oblast indikuje, která část bufferu je obsazena v praxi bývá velikost vyrovnávací paměti omezená paměť je propojena do kruhu (kruhový buffer) po n-té položce následuje opět první položka při zaplnění bufferu musí producent čekat ! b[2] b[3] b[4] b[n] b[n-1] směr rotace
58
Producent s kruhovým bufferem producer: repeat produce item v; while ( (in + 1) mod n = out) do { nothing }; b[in] := v; in := (in + 1) mod n forever;
59
Konzument s kruhovým bufferem consumer repeat while in = out do { nothing }; w := b[out]; out := (out + 1) mod n; consume item w forever;
60
Potřebujete oholit? u holiče jsou však jen 3 sedačky pro zákazníky a proto zde mohou obsluhovat pouze 3 holiči na pohovce je místo k sezení jen pro 4 čekající zákazníky ostatní zákazníci musí zůstat stát u dveří, dokud se neuvolní místo k sezení do místnosti se vejde celkem nejvýše 20 zákazníků, ostatní musí čekat venku nebo odejít pokladna pro placení je pouze jedna a inkasovat proto může pouze jeden holič
61
Barbershop Problem Vchod místo pro čekání ve stoje pohovka holící křesla Pokladna Východ
62
Barbershop Problem když je holič volný, přesune se nejdéle čekající zákazník z pohovky na křeslo nejdéle stojící zákazník pak usedne na pohovku v daném okamžiku může platit jen jeden zákazník holiči obsluhují zákazníky; pokud nečeká žádný zákazník, holiči spí
63
Co je nutné sledovat? kapacitu krámu a pohovky kapacitu holičů umístění právě jednoho zákazníka do volného křesla přítomnost zákazníka v křesle placení zákazníka po opuštění křesla přechod holiče na obsluhu pokladny
64
Barbershop Problem /* program barbershop1 */ semaphore max_capacity = 20; semaphore sofa = 4; semaphore barber_chair = 3; semaphore coord = 3; semaphore cust_ready = 0, finished = 0, leave_b_chair = 0, payment= 0, receipt = 0;
65
Customer void customer () { wait(max_capacity); enter_shop(); wait(sofa); sit_on_sofa(); wait(barber_chair); get_up_from_sofa(); signal(sofa); sit_in_barber_chair; signal(cust_ready); wait(finished); leave_barber_chair(); signal(leave_b_chair); pay(); signal(payment); wait(receipt); exit_shop(); signal(max_capacity) }
66
Barber void barber() { while (true) { wait(cust_ready); wait(coord); cut_hair(); signal(coord); signal(finished); wait(leave_b_chair); signal(barber_chair); }
67
Cashier void cashier() { while (true) { wait(payment); wait(coord); accept_pay(); signal(coord); signal(receipt); }
68
Monitory konstrukce ve vyšším programovacím jazyce, poskytující stejné služby jako semafory, ale je snadněji ovladatelná vyskytují se v řadě jazyků pro konkurenční programování (concurrent programming languages) Concurrent Pascal, Modula-3, uC++, Java... mohou být implementovány pomocí semaforů...
69
Monitor je softwarový modul, obsahující: jednu nebo více procedur inicializační sekvenci lokální datové proměnné charakteristiky: lokální proměnné jsou dostupné pouze prostřednictvím monitorových procedur proces vstupuje do monitoru vyvoláním některé jeho procedury v daném okamžiku může být v monitoru pouze jeden proces
70
Monitor monitor zajišťuje vzájemné vylučování program se tímto problémem nemusí zabývat sdílená data jsou chráněna tím, že se nacházejí v monitoru sdílená data jsou uzamčena v monitoru a procesy k nim mají přístup pouze prostřednictvím volání monitorových procedur synchronizaci procesů zajišťuje programátor použitím podmínkových proměnných reprezentují podmínky, které proces musí splnit před vstupem do monitoru
71
Podmínkové proměnné Condition variables jsou lokálními proměnnými monitoru (dostupné pouze v monitoru) lze k nim přistupovat a měnit je pouze následujícími 2 funkcemi: cwait(a) blokuje provádění volajícího procesu podmínkou (proměnnou) a proces může být znovu aktivován pouze když jiný proces provede csignal(a) csignal(a) obnoví provádění některého procesu blokovaného podmínkou (proměnnou) a pokud takových procesů existuje více, je vybrán jeden z nich pokud žádný takový proces neexistuje, neprovede se nic
72
Monitor čekající procesy jsou buď ve vstupní frontě nebo v podmínkové frontě proces se umísťuje do podmínkové fronty c n sám provedením cwait (c n ) csignal (c n ) vpustí do monitoru jeden z procesů čekajících ve frontě c n csignal (c n ) tedy blokuje volající proces a umísťuje ho do urgentní fronty (pokud ovšem csignal není poslední operaci monitorové procedury)
73
řešíme problém producentů a konzumentů pro synchronizaci použijeme monitor append() a take() jsou procedury monitoru jsou to jediné procedury, umožňující procesům přístup k vyrovnávací paměti pokud jsou tyto procedury korektní, bude synchronizace korektní pro všechny zúčastněné producenty i konzumenty ProducerI: repeat produce v; Append(v); forever ConsumerI: repeat Take(v); consume v; forever Monitor a problém svázaných P/C
74
Monitor potřebuje vyrovnávací paměť (sklad): buffer: array[0..k-1] of items; potřebuje dvě podmínkové proměnné: notfull csignal(notfull) indikuje že buffer není plný notempty csignal(notempty) indikuje, že buffer není prázdný potřebuje ukazatele do bufferu a čítače: nextin ukazuje na první volné místo pro přidávání nextout ukazuje na aktuální položku k odebrání count obsahuje počet položek v bufferu
75
Monitor boundedbuffer: buffer: array[0..k-1] of items; nextin:=0, nextout:=0, count:=0: integer; notfull, notempty: condition; Append(v): if (count=k) cwait(notfull); buffer[nextin]:= v; nextin:= nextin+1 mod k; count++; csignal(notempty); Take(v): if (count=0) cwait(notempty); v:= buffer[nextout]; nextout:= nextout+1 mod k; count--; csignal(notfull); Monitor a problém svázaných P/C
76
Předávání zpráv je nutné vzájemné vylučování dochází k výměně informací send (destination, message) receive (source, message)
77
vysílač a/nebo přijímač může (ale nemusí) být blokován neblokující send, neblokující receive neblokující send, blokující receive vysílač po odeslání zprávy pokračuje aby mohl připravovat zprávy co nejrychleji přijímač je blokován, dokud zpráva není doručena aby mohl okamžitě reagovat na doručení zprávy blokující send, blokující receive na doručení zprávy čeká přijímač i vysílač (rendezvous) Synchronizace při předávání zpráv
78
Adresace přímá adresace funkce send zahrnuje specifický identifikátor cílového procesu funkce receive může předem určit, od kterého procesu je zpráva očekávána zprávy od jiných procesů mohou být ignorovány speciální adresa (např. 0) specifikuje, že zpráva může přijít od kteréhokoliv procesu funkce receive může při volání dostat parametrem hodnotu, kterou má předat, když byla zpráva přijata to umožňuje při neblokujícím receive zjistit, že došla zpráva
79
Adresace nepřímá adresace zprávy se zasílají do sdílené datové struktury, skládající se z front říkáme jim poštovní schránky (mailboxes) jeden proces posílá zprávy do schránky, druhý si zprávy ze schránky vyzvedává
80
Mailboxy a porty mailbox může být vlastněn jedním párem vysílač/přijímač tentýž mailbox může být sdílen několika vysílači a přijímači OS pak může dovolit rozlišení více typů zpráv Port je mailbox svázaný s jedním přijímačem a více vysílači používá se pro aplikace typu klient/server (server je přijímačem)
81
Vlastnictví portů a mailboxů port je obvykle vlastněn přijímačem port se ruší ukončením procesu přijímače mailbox vytváří OS na žádost procesu, který se tak stává jeho vlastníkem mailbox se ruší na žádost procesu- vlastníka nebo když je tento proces ukončen
82
Obecný formát zprávy Message Contents záhlaví zprávy tělo zprávy Message Type Destination ID Source ID Message Length Control Info.
83
Problém čtenářů a pisatelů jakýkoliv počet čtenářů může souběžně číst obsah souboru v daném čase může do souboru zapisovat pouze jeden pisatel pokud pisatel zapisuje do souboru, nemůže jeho obsah číst žádný čtenář
84
Dosažení vzájemného vylučování přenosem zpráv vytvoření mailboxu mutex sdíleného n procesy send() is neblokující receive() je blokující když je mailbox mutex prázdný Inicializace: send(mutex, “go”); První proces P i, který provede receive() může vstoupit do CS ostatní procesy budou blokovány dokud P i neodešle zprávu Process Pi: var msg: message; repeat receive(mutex,msg); CS send(mutex,msg); RS forever
85
Problém svázaných P/C přenosem zpráv producenti umisťují položky odesíláním zpráv do mailboxu mayconsume mailbox mayconsume slouží jako buffer: konzument může konzumovat, jestliže je v mailboxu alespoň jedna zpráva Na začátku je mailbox mayproduce naplněn k prázdnými zprávami (k= velikost bufferu) počet položek v bufferu se zvětší každým příchodem zprávy a zmenší každým odebráním zprávy může obsluhovat více producentů i více konzumentů
86
Producer: var pmsg: message; repeat receive(mayproduce, pmsg); pmsg:= produce(); send(mayconsume, pmsg); forever Consumer: var cmsg: message; repeat receive(mayconsume, cmsg); consume(cmsg); send(mayproduce, null); forever Problém svázaných P/C přenosem zpráv
Podobné prezentace
© 2024 SlidePlayer.cz Inc.
All rights reserved.