4. konzultace (4 hodiny) 28. 3. 2014 Studijní materiály najdete na adrese:

1. 4. konzultace (4 hodiny) 28. 3. 2014 Studijní materiály najdete na adrese: http://www.uai.fme.vutbr.cz/~vdumek/

2. Implementace služby CREATE (demonstrační verze) vytvoření záznamu na zásobníku #include <…..> int create(void (*procaddr)(),unsigned ssize, short priority,char *name,short nargs,unsigned *args[]) { int pid, i;/* pid - číslo nového procesu */ struct pentry *pptr; unsigned *saddr;/* adresa zásobníku */ if(priority(1,MAX)||((saddr=getstk(ssize)==0)|| (pid=newpid())==SYSERR) return SYSERR; numproc++;/* zvýšení počtu procesů */ pptr=&proctab[pid]->pstate=PRNEW; for(i=0;i<N&&(pptr->pname[i]=name[i])!=0;i++); pptr->pprio=priority; pptr->plimit=saddr; pptr->pbase=saddr+ssize; pptr->pstklen=ssize; pptr->pargs=nargs; pptr->paddr=procaddr; saddr=pptr->pbase; for(i=0;i<nargs;i++) *saddr--=args[i]; *--saddr=procaddr; napln_reg(); pptr->svarea=saddr;/* ukládací oblast kontextu */ return(pid); } parametry adresa procesu vstupní bod funkce nulování registrů procesoru SP vrchol zásobníku pid = fork()

3. Služba CREATE Vytvoření běhového a datového kontextu procesu. • vytvoření PCB procesu:identifikace procesu stav procesu (READY, ihned k přeplánování) řídicí informace • zapojení kontrolních mechanismů • inkrementace čítače procesů • alokace paměti pro uživatelský zásobník • alokace paměti pro kernel zásobník • nastavení obsahu registrů(zavede se do procesoru při přeplánování) - nastavení ukazatelů paměti(private adress space, shared adress space)

4. Implementace služby RESCHED #include <conf.h> #include <proc.h> #include <q.h> /*---------------------------------------------------------------- služba přeplánuje, spustí proces s nejvyšší prioritou -----------------------------------------------------------------*/ int resched(void) { register struct pentry *optr; /* směrník na starý proces */ register struct pentry *nptr; /* směrník na nový proces */ if((optr=&proctab[CURRPID])->pstate==PRCURR) { if(firstkey(rdyqueue)<optr->pprio) return OK; optr->pstate=PRREADY; insert(currpid, rdyqueue, optr->pprio); } nptr=&proctab[(currpid=getfirst(rdyqueue))]; nptr->pstate=PRCURR; preempt=QUANTUM; lastsva=&(optr->svarea); newsva=&(nptr->svarea); ctxsw(); return OK; } - bere v úvahu stav procesů a zajis- tí přepnutí kontextu - CURRPID - číslo aktivního procesu - nemusí dojít k přeplánování - realizováno jako nepřerušitelné - insert zařazuje proces na konec procesů se stejnou prioritou - pouhé volání služby zajistí střídání procesů podle sdílení času - je volána v rámci přerušení časovače - interní pomocná služba správce procesů - READY

5. Služba RESCHED • přepnutí kontextu • kontrola nutnosti přepnutí • umístění procesu do prioritní fronty (na obecné místo) • přeznačení stavu procesů v PCB Služba READY • označení stavu procesu • parametr RESCHYES, RESCHNO • umístění procesu do prioritní fronty (na obecné místo) • přeplánování až po zařazení posledního procesu

6. Implementace služby READY #include <conf.h> #include <kernel.h> #include <proc.h> #include <q.h> /*------------------------------------------- Služba READY, která převede proces do ready fronty a potom vyvolá přeplánování --------------------------------------------*/ int ready(short pid, short resch) { register struct pentry *pptr; (pptr=&proctab[pid])->pstate=PRREADY; insert(pid, rdyhead, pptr->pprio); if(resch) resched(); return OK; } /* konec funkce */ RESCHYES definováno jako 1 RESCHNO definováno jako 0 - pid - identifikační číslo procesu pro frontu READY (rdyhead) - správně nastaví stavovou informaci v tabul- ce procesů, zařadí jej do fronty READY, vy- volá přeplánování - parametr resch - proti přeplánování po za- řazení jednotlivých procesů ze skupiny - priorita následujících procesů může být vyšší - resch se nastaví až při zařazování posledního procesu

7. Implementace služby RESUME #include <conf.h> #include <kernel.h> #include <proc.h> /* -------------------------------------- služba převede proces ze stavu SUSPENDED do stavu READY a vrací prioritu procesu ---------------------------------------*/ int resume(short pid) { struct pentry *pptr; int prio; if((pptr=&proctab[pid])->pstate!=PRSUP) return SYSERR; PRIO=pptr->pprio; ready(pid,RESCHYES); return PRIO; } - slouží k převodu procesu do READY fronty - kontrola stavu procesu - proměnná PRIO - uschování priority procesu proti ztrátě během přeplánování

8. Služba RESUME • jestliže není stav SUSPEND, tak chyba • převedení procesu ze stavu SUSPEND • zařazení procesu do prioritní fronty • použit parametr RESCHYES, priorita procesu v lokální proměnné SlužbaSUSPEND • pouze ze stavu CURRENT(přeplánuje), READY(vyřadí z fronty) • nesmí být nulový proces • procesy ve stavu SUSPEND jsou bez fronty

9. Implementace služby SUSPEND #include <conf.h> #include <kernel.h> #include <proc.h> /*------------------------------------------------------- služba převede proces ze stavu READY nebo CURRENT do stavu SUSPEND -------------------------------------------------------*/ int suspend(short pid) { struct pentry *pptr; int prio; if(pid==NULLPROC || (pptr=&proctab[pid])->pstate!=PRCURR&&pptr->pstate!=PRREADY) return SYSERR; PRIO=pptr->pprio; if(pptr->state==PRREADY) { dequeue(pid); pptr->pstate=PRSUSP; } else { pptr->pstate=PRSUSP; resched(); } return PRIO; } - musí zpracovat proces ve stavu READY, CURRENT - ze stavu READY se vyřadí z fronty - ze stavu CURRENT (proces suspenduje sám sebe) se vyvolá přeplánování - ve stavové informaci aktivního procesu předáme službě RESCHED stav PRSUSP

10. Implementace služby KILL - musí zpracovat proces v libovolném stavu - snížení počítadla procesů - uvolnění paměti pro zásobník - označení položky v tabulce procesů PRFREE - odstranění procesu z fronty - úprava semaforu #include <conf.h> #include <kernel.h> #include <proc.h> #include <sem.h> #include <mem.h> /********************************* KILL - odstraníproces ze systému *********************************/ int kill(short pid) { struct pentry *pptr; if ((pptr=&proctab[pid])->pstate == PRFREE) return SYSERR; -- NUMPROC; free(pptr->plimit, pptr->pstklen); switch(pptr->pstate) { case PRCURR: pptr->pstate=PRFREE; resched(); break; /* sebevražda, nikdy se nevrátí ... */ case PRWAIT: semaph[pptr->psem].semcnt++; break; case PRSLEEP: case PRREADY: dequeue(pid); break; } pptr->pstate=PRFREE; return OK; }

11. SlužbaKILL • odstraní proces ze systému, musí existovat • při odstranění aktivního procesu musí být přeplánování • ze stavu SLEEP, READY a WAIT vyřazení z fronty • úprava stavu obecného semaforu SlužbaSLEEP • proces je uložen do DELTA listu • stav DELTA listu je uchován v globálních proměnných - přeplánování (uspává se vždy aktivní proces)

12. Implementace služby SLEEP - proces je zařazen do delta listu - používá globálních proměnných CURRPID, slnempty, sltop - čas pro uspání předán jako parametr - jednotky záleží na implementaci #include <kernel.h> #include <proc.h> #include <q.h> #include <sleep.h> void sleep(unsigned for_time) { if(for_time != 0) { insert(currpid, clockqueue, for_time); slnempty=1; sltop=DELTA(clockqueue);/* funkce vrací čas prvního procesu */ proctab[CURRPID].pstate=PRSLEEP; } resched(); }

13. Implementace služby WAKEUP - není k dispozici vrstvám OS, pouze je volána v rámci obsluhy přerušení časovače - slnempty informuje o spícím procesu - sltop obsahuje čas do probuzení prvního procesu v delta listu #include <kernel.h> #include <proc.h> #include <q.h> #include <sleep.h> /**************************************** volána pouze v případě neprázdného delta listu ****************************************/ void wakeup(void) { while (nonempty(clockqueue) && firstkey(clockqueue) == 0) ready(getfirst(clockqueue),RESCHNO); if(slnempty=nonempty(clockqueue)) sltop=DELTA(clockqueue); resched(); }

14. Memory Management • požadavky řízení paměti (cache, relokace, ochrana, sdílení, logická organizace, fyzická organizace) • dělení paměti (blokové přidělování) • stránkování • segmentace • virtuální paměť

15. CPU Word Transfer Cache Block Transfer Main memory Cache paměť - drahá a velmi rychlá paměť - kontakt s pomalejší a větší hlavní pamětí - OS a uživatelské procesy ji nevidí - je v interakci s HW správy paměti (MMU) - hledání odkazovaného slova v cache • při neúspěchu přesun dalšího bloku dat • prostorová lokalita

16. la0 fa0 la1 fa1 procesor RAM DAT - MMU lan fan LAP FAP Logický adresový prostor Fyzický adresový prostor Adresové prostory RAM LAP - logické adresy, instrukční soubor procesoru FAP - fyzické adresy, HW řešení DAT - Dynamic Address Translation MMU - Memory Management Unit správa adresových prostorů (oddělení LAP a FAP pro jednotlivé procesy, rozdělení FAP pro LAP)

17. Ochrana paměti - SW - žádný proces by neměl narušit adresový prostor jiného procesu nebo dokonce operačního systému - v multitaskovém prostředí je tento požadavek jedním z nejdůležitějších, nutná jednotka řízení paměti, nabízí dva mechanismy - paměť, která není dosažitelná nemůže být poškozena, jedná se o vedlejší efekt virtualizace (každý proces má jiné stránkové tabulky) - ochrana sdílených dat, jedná se o knihovny, které jsou sdílené více procesy, jednotka řízení paměti má k dispozici prostředky, kterými označí stránku pouze pro čtení (1 bit), v případě snahy o modifikaci dojde k vyvolání výjimky a zrušení procesu Řešení s podporou HW ochrana systémových dat před procesy, procesor rozlišuje běh v režimujádra OS a režimu uživatelském, jednotka řízení paměti nabízí prostředky pro označení stránek pro běžný proces a pro OS, při přístupu do paměti se dělá komparace, v jakém režimu se nachází procesor, při porušení se generuje přerušení Mezní registry: - dva registry s nejnižší a nejvyšší dostupnou adresou, odkaz mimo rozsah způsobí výjimku, nastavení mezních registrů musí být privilegovaná instrukce. Zámky a klíče: - paměť je rozdělena na stránky, každé je přiřazen zámek (celé číslo), procesor má speciální registr (klíč), procesor může používat pouze ty stránky paměti, které mají zámek nastavený na stejnou hodnotu, jako je klíč (klíč s hodnotou 0 je univerzální – přístup je povolen ke každé stránce). Tento způsob ochrany se užívá i u dynamických bloků.

18. Blokové přidělování Fragmentace paměti – hlavní nevýhoda, důsledek přidělování nestejně velkých bloků paměti a jejich uvolňování v různých okamžicích, pro omezení externí fragmentace se přidělují stejně veliké bloky (zvýšení režie), spojování více bloků, pro úplné zamezení - uvolňování v opačném pořadí než se alokuje, nepřijatelný diktát chování procesů, některé procesy si OP potřebují držet stále, drasticky by se snižovala průchodnost OS, musí být vnitřní věcí správce OP. Externí fragmentace – dost volné paměti, není dostupná v souvislé díře Interní fragmentace – přidělená oblast je větší, než bylo požadováno Redukce externí fragmentace – slučování nesousedních děr posuvem obsazených oblastí (bliter). Při přesouvání bloků dat je nutné zachování transparentnosti pro procesy - požadavek na překlad adres, pokud je k dispozici, není důvod nepoužít virtualizaci - virtuální paměť. strategie pro jednoduché OS nebo jednorázové a krátkodobé úkoly, proces musí vědět, kolik OP potřebuje a explicitně si ji vyžádat (požadavek je buď akceptován, nebo odmítnut), je třeba udržovat informace o vlastnících bloků, o volných blocích (tabulky s informacemi), potřebná znalost délky bloku, adresa dalšího bloku nemusí být explicitně uvedena (bloky navazují)

19. P1 P1 volná fragmentováno P2 defragmentováno P2 P3 volná P4 P3 volná volná P4 Odstranění fragmentace - setřásání

20. Informace v bloku Informace ve zvláštní struktuře Proces1 Další blok Proces1 Proces1 15KB Data P1 Proces2 Proces2 Proces2 10KB Proces3 Další blok Proces3 25KB Data P2 Blokové přidělování Informace o blocích v datových strukturách správce, potřeba další paměti a zvýšení režie, počet bloků předem neznáme, řešením je přidělení většího bloku, do volného místa uložit informace o samotném bloku i o adrese následujícího. Nevýhodou je promíchání systémových informací a paměťových bloků. Při nedokonalé ochraně paměti hrozí zhroucení OS.

21. 8 MB 8 MB 8 MB 2 MB 4 MB 8 MB 8 MB 8 MB 8 MB 8 MB 12 MB 8 MB 8 MB 16 MB 8 MB 8 MB Blokové přidělování - statické Pevná velikost přidělovaných bloků– umožňuje umístění procesu menšího nebo stejného, pokud jsou všechny bloky obsazené a žádný proces není ve stavu READY nebo RUN, je možné odkládat bloky stejné velikosti • nezáleží na tom, který blok se použije (jsou stejné) • nabízený prostor je nedostatečný, nutnost zavedení překryvů • využití paměti je extrémně neefektivní • i malý požadavek čerpá celý blok • vzniká interní fragmentace bloky nestejné velikosti • existují dvě možnosti čerpání bloků

22. 8 MB 8 MB 2 MB 2 MB 4 MB 4 MB 8 MB 8 MB nové procesy nové procesy 8 MB 8 MB 12 MB 12 MB 16 MB 16 MB Způsob obsazení bloků • jedna fronta procesů pro každý blok– pro každý blok je jedna plánovací fronta procesů, výhodou je omezení interní fragmentace • jedna fronta procesů pro všechny bloky– možnost stanovit preferenci mezi odkládáním malých procesů a jejich umístění ve větším prostoru (zvýšení interní fragmentace versus zvýšená průchodnost operačního systému)

23. OS OS OS OS proces 5 proces 5 proces 5 proces 5 proces 8 volné proces 9 proces 9 proces 10 volné volné proces 2 proces 2 proces 2 proces 2 volné volné volné volné Blokové přidělování - dynamické Díra – blok dostupné paměti, díry mají různý rozměr, jsou roztroušeny po FAP, při vzniku procesu se procesu přidělí dostatečně velká díra, OS udržuje informaci o přidělených oblastech a dírách

24. first fit best fit Poslední worst fit next fit last fit Alokační strategie First fit - přidělí oblast v první díře, která má dostatečnou velikost, zbytek je novou dírou, jednoduchá, rychlá, nemá vliv na fragmentaci Best fit - přidělí oblast v nejmenší díře, která má ještě dostatečnou velikost, mírně omezuje fragmentaci, pomalá, větší režie, zanechává malé díry, šetří velké díry pro velké požadavky Worst fit – přidělí oblast v největší díře, pomalá, zanechává největší díru Last fit – obsazuje paměť od nejvyšších adres, někdy výhodný způsob (místo pro zásobník) Next fit – prohledává paměť za posledním umístěním poslední alokovaný alokovaný volný nově alokovaný

25. Systém „blíženců“ • zajímavým kompromisem mezi statickým a dynamickým přidělováním bloků je tzv. „Buddy System“ (Unix SVR4). Dostupné jsou paměťové bloky o velikosti 2K, L <= K <= U, kde představuje: 2L – nejmenší velikost alokovaného bloku 2U – největší velikost alokovaného bloku (dostupná paměť) Řešení požadavku na přidělení bloku o velikosti S: - začne se s celým blokem velikosti 2U. Jestliže platí 2U-1 < S < 2U, přidělí se celý blok délky 2U, jinak se blok rozdělí na dva „blížence“ o rozměrech 2U-1. Jestliže platí 2U-2 < S < 2U-1, přidělí se jeden z blíženců, jinak opět dojde k rozdělení. Postup se opakuje, dokud se nezíská nejmenší možný blok s velikostí větší nebo rovnou s požadavkem S. Jakmile se „blíženci“ uvolní, tak splývají. Operační systém udržuje několik seznamů děr: - i-tý seznam je seznam děr o velikosti 2i - kdykoliv se v (i+1) seznamu vyskytne pár „blíženců“, jsou z (i+1) seznamu odstraněny, sloučeny a vloženy do i-tého seznamu. Když se požaduje oblast o velikosti k, kde 2i+1 < k < 2i, nejprve se zkoumá i-seznam a je-li prázdný, zkoumá se (i+1) seznam ...

26. 1M A - 128K 128K 256K 512K A - 128K 128K B - 256K 512K A - 128K C 64K 64K B - 256K 512K Req. C – 62K A - 128K C 64K 64K B - 256K D - 256K 256K Req. D – 256K A - 128K C 64K 64K 256K D - 256K 256K Rel. B 128K C 64K 64K 256K D - 256K 256K Rel. A 256K E - 128K C 64K 64K 256K D - 256K Req. E – 75K E - 128K 128K 256K D - 256K 256K Rel. C 512K D - 256K 256K Rel. E 1M Buddy System Req. A – 100K Req. B – 240K volná přidělená

27. RAM logická adresa p d procesor f d fyzická adresa p f Stránkování LAP se dělí na logické stránky, FAP na fyzické stránky (frame), oboje má pevnou délku, délka je mocninou 2, zobrazení LAP do FAP se děje pomocí tabulky stránek, technika trpí vnitřní fragmentací, logickou adresu generuje procesor, číslo stránky (p – index do tabulky stránek, indexovaný řádek obsahuje číslo rámce f), offset (d – adresa ve stránce, dohromady s f tvoří fyzickou adresu)

28. Stránkování paměti - metoda, jak se vyrovnat s externí fragmentací, logická adresa (použita v programu) má dvě složky (číslo stránky a offset), velikost stránky bývá v KB (při velikosti 4 KB je pro offset potřeba 12 bitů, spodních 12 bitů je offset, zbytek je pro číslo stránky, číslo stránky se použije jako index do tabulky stránek (každý proces má svoji vlastní), v tabulce stránek je uvedeno číslo rámce ve fyzické paměti, k tomuto rámci se připojí offset => fyzická adresa, výhodou je odstranění externí fragmentace, není nutné přemísťování bloků v paměti, poslední stránka procesu trpí interní fragmentací, je potřeba hardwarová podpora, součet paměťových nároků procesu nemůže překročit velikost fyzické paměti

29. Free frame list 0 Proces A Proces B Proces C Proces D A0 13 0 0 0 - 0 7 0 4 1 A1 14 1 1 1 - 1 8 1 5 2 A2 2 2 2 - 2 9 2 6 3 3 3 10 3 11 3 A3 4 12 4 B0 4 D0 5 B1 5 D1 6 B2 6 D2 7 C0 8 C0 9 C0 10 C0 11 D3 12 D4 13 14 Příklady stránkování - proces D nezabírá souvislou oblast - nedochází k externí fragmentaci - vnitřní fragmentace je problém poslední stránky procesu - OS udržuje PT pro každý proces - zmenšování délky stránky – minimalizace vnitřní fragmentace, prodlužování PT

30. Segmentace paměti Segmentace paměti: - fyzická adresa se získává z páru segment + offset, obsah segment registru nastavuje OS, pro uživatelský program je nepřístupný, adresní prostor každého procesu začíná na hodnotě 0, odpadají problémy s relokací, rozdělení na segmenty odpovídá struktuře paměťového prostoru procesu (kód, konstanty, proměnné, zásobník, halda), procesy řízené stejným programem mohou sdílet kód programu a konstanty, je možné dynamické přemísťování segmentů za běhu procesu, možnost dodatečného zvětšování adresního prostoru, možnost sdílení segmentů, není nutné provádět relokaci programu, nevýhodou je, že součet nároků procesů <= velikost paměti (odkládání segmentů na disk – může být časově náročné), nutná hardwarová podpora segmentace, pro odstranění fragmentace se užívá setřásání segmentů, k ochraně se užívá mezní registr na číslo segmentu (segmenty mají různou délku)

31. Segmentace paměti operační paměť segment offset Segment A base limit base limit Segment B base limit base limit base limit Segment C base limit base limit base limit fyzická adresa

32. Virtuální paměť - virtualizace je nejdokonalejší strategie správy paměti, musí být k dispozici MMU -jednotkařízení paměti • zajišťuje transparentnost paměti pro procesy Nutné podmínky pro realizaci virtuální paměti: • schopnost procesoru zpracovávat přerušení • opakování přístupu do paměti • jednotka řízení paměti musí být schopna zajistit ochranupaměti - při pokusu o práci s neexistující pamětí se vyvolá přerušení, jednotka řízení paměti neexistující paměť doplní, zopakuje se přístup do paměti

33. Logická stránka 0 Fyzická stránka 0 Fyzická stránka 1 Logická stránka 1 Logická stránka 2 Fyzická stránka 2 ? Logická stránka 3 Fyzická stránka 3 Logická stránka 4 Fyzická stránka 4 Logická stránka 5 Fyzická stránka 5 Logická stránka 6 Virtuální paměť – zjednodušený princip - logická adresa,účastní se překladu, leží v adresovém prostoru - fyzická adresa, leží v OP, platná po překladu adres - logickéstránkyreprezentují adresový prostor - fyzické stránky reprezentují OP - odkládací prostor na disku - pokud není k dispozici žádná volná fyzická stránka, vezme se obsah některé z alokovaných auloží se na disk, uvolněná fyzická stránka se spojí s logickou stránkou - při požadavku čtení z odložené stránky se vyvolá přerušení - výpadek stránky a postupuje se stejně, jako při požadavku na volnou fyzickou stránku

34. 2 3 2 1 5 2 4 5 3 2 5 2 2 2 2 2 2 2 4 4 4 2 2 2 3 3 3 3 3 3 3 3 3 3 3 1 5 5 5 5 5 5 5 5 2 3 2 1 5 2 4 5 3 2 5 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 5 5 5 5 5 5 5 5 1 1 1 4 4 4 2 2 2 Algoritmy určení oběti OPT (optimální nahrazování) - proces s 5 stránkami, rezidentní množina 3 stránky - oběť – nejpozdější ze všech následných odkazů - generuje nejmenší počet výpadků stránky - neimplementovatelný, srovnávací normál LRU (Least Recently Used) - obětí je nejdéle neodkazovaná stránka - princip lokality -> pravděpodobnost referencování je malá - výkon blízký OPT - velmi drahé řešení, velká režie - pseudo LRU – „used“ bit - čítač má konečnou kapacitu

35. 2 3 2 1 5 2 4 5 3 2 5 2 2 2 2 2 5 5 5 5 3 3 3 3 3 3 3 3 2 2 2 2 2 5 5 1 1 1 4 4 4 4 4 2 2 3 2 1 5 2 4 5 3 2 5 2 2 2 2* 2* 2 2* 2* 2* 2 2* 2* 2* 3 3 3 5 5 5 5* 5 5 5* 5* 1 1 1 4 4 3 3 3 3 Algoritmy určení oběti FIFO - obětí je nejdéle zobrazená stránka ve FAP - rámce jsou organizovány do cyklického bufferu - když je buffer plný, nahrazuje se nejstarší stránka • méně efektivní, jednoduchá implementace "Máš ještě 1 šanci" / hodiny - výběr oběti – cyklické procházení rámci - referencí se získává "život" (nekumulativně) - výběrem za oběť se "život" ztrácí - oběť bez * se nahrazuje

36. Srovnání algoritmů určení oběti

37. Souběžnost procesů • problém souběžnosti vzniká v prostředí prokládání i překrývání • příčinou jsou sdílená data a prostředky, procesy používají a modifikují sdílená data, operace zápisu musí být vzájemně výlučná, operace zápisu musí být vzájemně výlučná s operací čtení, operace čtení bez modifikace mohou být souběžné • kooperace mezi procesy,potřeba synchronizace běhu, čekání na událost vyvolanou jiným procesem • neřízeným přístupem ke sdíleným údajům mohou procesy (sledy) získat nekonzistentní pohled na data, akce prováděné souběžnými procesy jsou závislé na pořadí prokládání jejich běhů • obtížná lokalizace chyb programování • výsledky procesů musí být nezávislé na rychlosti běhu jednotlivých procesů • část kódu, kde se přistupuje ke sdílenému prostředku se nazývá kritické sekce procesu sdružená s tímto prostředkem • většinou je potřeba zajistit, aby v kritické sekci sdružené s jistým prostředkem, byl nejvýše jeden proces

38. zpráva P1 P1 P2 P2 D událost Kooperace mezi procesy sdílení - procesy používají a modifikují sdílená data (soubory, proměnné, databázové záznamy), operace zápisu musí být vzájemně výlučné, zápis musí být výlučný se čtením, čtení může být realizováno souběžně, pro zabezpečení integrity dat se používají kritické sekce, sledy mají společnou datovou oblast komunikace - dají se koordinovat i procesy na jiném procesoru (počítači), může dojít k uváznutí v důsledku čekání na zprávu od jiného procesu, může dojít ke stárnutí (dva procesy si posílají zprávy, třetí se nemůže dočkat)

39. Uváznutí a stárnutí procesů Důsledkem snahy synchronizovat běh procesů je jejich uváznutí a stárnutí. Uváznutí - množina procesů P uvázla, pokud každý proces Pi z množiny P čeká na událost, kterou vyvolá pouze některý z procesů z P - nutné (nepostačující) podmínky: vzájemné vyloučení (pouze jeden proces může používat prostředek), postupné uplatňování požadavků (Hold and Wait, proces může při žádosti o prostředek již něco vlastnit), nepřípustnost předbíhání (žádnému procesu se nesmí nic násilně odebrat) - postačující podmínka (důsledek nutných): cyklické čekání procesů - událost – uvolnění prostředku (paměť, soubor, I/O, …), zaslání zprávy Stárnutí - požadavky jednoho nebo více procesů nebudou splněny v konečném čase (priorita, prevence uváznutí, …) - některé operační systémy (Unix SVR4) problém uváznutí a stárnutí ignorují, tváří se, že tento problém neexistuje

40. Vznik uváznutí procesů proces D proces A NESMÍ NASTAT Y V proces C proces B X W

41. shared int obsazeno=0; P0 while(1) { while(obsazeno) ; obsazeno=1; KS; obsazeno=0; } P1 while(1) { while(obsazeno) ; obsazeno=1; KS; obsazeno=0; } Možnosti řešení problému kritické sekce Softwarové řešení aktivní čekání, naivní řešení, myšlenka zamykacích proměnných není zcela chybná Hardwarové řešení pomocí speciální instrukcí procesoru, opět aktivní čekání (busy waiting), snižuje se průchodnost OS Prostřednictvím operačního systému potřebné datové struktury určené k synchronizaci poskytuje OS (semafory), pasivní čekání (procesy nesoutěží o procesor), podpora volání synchronizačních služeb v programovacích systémech/jazycích (monitory, zasílání zpráv), hrozí uváznutí nebo stárnutí

42. Semafory - programový prostředek, který je umístěn na začátku kritické sekce. Pokud kolem něj projede proces, semafor reaguje změnou stavu. Semafory mohou být binární - první proces nastaví semafor na červenou,ostatní po dobu jejího trvání ztrácí procesor a odchází do fronty semaforu nebo obecné - stav se mění na hodnotu celého čísla - tradiční jméno binárního semaforu je mutex (mutual exclusion) - synchronizační prostředek poskytovaný operačním systémem - nahrazuje režim "busy waiting" pasivním čekáním - jedná se o zobecnění instrukce TST, nahrazení dvoustavové proměnné čítačem (v případě obecného semaforu) - poprvé popsal Edsger Wybe Dijkstra (1965) - původní pojmenování operací proberen (testovat) a verhogen (zvětšit) - stav semaforu >= 0 – počet procesů, které mohou plně provést službu wait (nepřejdou do fronty semaforu) - stav semaforu < 0 – počet čekajících procesů - pro stejný semafor nesmí být žádné dva procesy současně ve wait a signal, i v případě více procesorů - wait i signal jsou vlastně KS (typicky pouze desítky instrukcí)

43. Obecný semafor - obecné semafory - kombinace fronty a číselné hodnoty, číslo udává, kolikrát je předplacena služba lock (kolikrát je možné ji provést, aniž by bylo potřeba proces zastavit), záporná hodnota udává, kolikrát se na semafor čeká - realizace obecného semaforu je provedena pomocí služeb WAIT a SIGNAL /* sem.h */ #define SFREE '1' #define SUSED '2' struct sentry { signed short semcnt, /* hodnota semaforu */ squeue; /* fronta */ }; extern struct sentry semaph[]; /* semafory */ Typ SEMAPHOR

44. Implementace služby WAIT - snížení hodnoty o 1, pokud je záporné, uloží se proces do fronty semaforu, stav se převede do WAIT, vyvolá se přeplánování - do tabulky procesů je poznamenán i semafor, pro snadnější lokalizaci procesu (není potřeba procházet všechny fronty) #include <conf.h> #include <kernel.h> #include <proc.h> #include <q.h> #include <sem.h> /****************************** WAIT - převede aktuální proces do stavu čekání na semafor ******************************/ void wait(int sem){ register struct sentry *sptr; register struct pentry *pptr; sptr=&semaph[sem]; if(--(sptr->semcnt) < 0){ (pptr=&proctab[currpid])->pstate=PRWAIT; pptr->psem=sem; enqueue(currpid,sptr->squeue); resched() } }

45. SlužbaWAIT • dekrementuje hodnotu semaforu • pokud je hodnota větší jak nula, proces pokračuje • v případě záporné hodnoty je proces zařazen do fronty semaforu • poznamená se, který semafor proces drží • provede se přeplánování SlužbaSIGNAL • inkrekrementuje hodnotu semaforu • pokud je hodnota záporná nebo nulová, proces je zařazen do READY fronty (prioritní) • parametrem RESCHYES se zajistí okamžité přeplánování

46. Implementace služby SIGNAL hodnota se zvýší o 1, pokud je výsledek zápornýnebo roven 0, převede se proces pomocí služby ready doprioritní fronty (z fronty semaforu) #include <conf.h> #include <kernel.h> #include <proc.h> #include <q.h> #include <sem.h> /******************************* SIGNAL - implementace služby *******************************/ void signal(int sem) { register struct sentry *sptr; sptr=&semaph[sem]; if(++sptr->semcnt <= 0) ready(getfirst(sptr->squeue), RESCHYES); return OK; }

47. PRODUCENT KONZUMENT Synchronizace P-K obecným semaforem - jeden proces vyčká na událost generovanou druhým procesem - proces může být pouze v jedné frontě, z fronty binárního semaforu odchází přes službu resume do ready fronty - některé implementace nevhodné pro binární semafory (výměna dat přes sdílenou paměť) - modelový případ producent – konzument(obecné paradigma kooperace procesů) - buffer s produkovanými a dosud nezpracovanými položkami (buffer konečné kapacity k)

48. - pomocí implementace obecných semaforů se zajistí efektivní fungování mezi konzumentem a producentem Kód producenta Kód konzumenta for(;;) for(;;) { { char data=vytvor_data(); char data; wait(B); wait(A); uloz_do_sdilene_pameti(); data=cti_ze_sdilene_pameti(); signal(A); signal(B); } zpracuj_data(); } - semafor A je inicializován na 0, semafor B je inicializován na velikost sdílené paměti • v případě souběhu producenta a konzumenta jsou data obhospodařována průběžně, v jiném případě se zastaví produkce, nebo čerpání • návaznost na inkrementaci semaforu ve službě KILL (stav WAIT), kdy se proces odstraňuje z každé fronty

49. A proces V držení P2 požadavek prostředek se čtyřmi instancemi P1 požadavek V držení B Modelování uváznutí - alokační graf, znázornění přidělených a požadovaných prostředků, počet instancí každého prostředku - prostředek Ri má Wi instancí, jsou opakovaně přístupné (žádost, používání, uvolnění) - uzly: prostředky, procesy, hrany: požadavkové (orientace z procesu na prostředek), přidělovací (orientace z prostředku na proces) - pokud alokační graf neobsahuje cyklus – není uváznutí - pokud alokační graf obsahuje cyklus – jedinečné prostředky = uváznutí, násobné prostředky (více instancí) = nemusí uváznout

50. Neobsahuje cyklus Obsahuje cyklus R1 R3 P1 P2 P3 R1 R3 R4 R2 R4 R2 P1 P2 P3 Ochrana před uváznutím - prevence: ruší se platnost některé nutné podmínky, k uváznutí nikdy nedojde - detekce: detekuje se existence uváznutí, řeší se následky - obcházení: zamezuje se současné platnosti nutných podmínek, prostředek se nepřidělí, pokud by hrozilo uváznutí, hrozí stárnutí - ignorace: nejjednodušší metoda, pokud k uváznutí dojde – reboot, nelze použít pro životně kritické systémy