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

Prezentace na téma: "4. konzultace (4 hodiny) 28. 3. 2014 Studijní materiály najdete na adrese:"— Transkript prezentace:

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

2 vstupní bod funkce SP vrchol zásobníku pid = fork() parametry adresa procesu nulování registrů procesoru #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 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); } Implementace služby CREATE (demonstrační verze) vytvoření záznamu na zásobníku

3 Služba CREATE -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) Vytvoření běhového a datového kontextu procesu.

4 Implementace služby RESCHED - 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 #include /*---------------------------------------------------------------- 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) 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; }

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 - 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 #include /*------------------------------------------- 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 Implementace služby READY

7 - 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í #include /* -------------------------------------- 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; } Implementace služby RESUME

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žba SUSPEND - 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 - 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 #include /*------------------------------------------------------- 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; }

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 /********************************* 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žba KILL - 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žba SLEEP - 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 #include 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(); } - 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

13 Implementace služby WAKEUP #include /**************************************** 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(); } - 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

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 Cache paměť Main memory Cache CPU Block Transfer Word Transfer - 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 Adresové prostory RAM LAPFAP procesorRAM la n la 1 la 0 DAT - MMU fa n fa 1 fa 0 Logický adresový prostorFyzický adresový prostor 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žimu já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 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í) Blokové přidělování

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

20 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. Proces1 15KB Proces2 10KB Proces3 25KB Proces1 Proces2 Proces3 Informace ve zvláštní struktuře Proces1 Další blok Data P1 Proces2 Další blok Data P2 Informace v bloku Blokové přidělování

21 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 8 MB 2 MB 4 MB 8 MB 12 MB 16 MB 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 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) 8 MB 2 MB 4 MB 8 MB 12 MB 16 MB nové procesy nové procesy 8 MB 2 MB 4 MB 8 MB 12 MB 16 MB

23 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 OS proces 5 proces 8 proces 2 volné OS proces 5 volné proces 2 volné OS proces 5 proces 9 proces 2 volné OS proces 5 proces 9 proces 2 volné proces 10 volné Blokové přidělování - dynamické

24 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 Alokační strategie alokovaný volný nově alokovaný poslední alokovaný Poslední first fit best fit last fit worst fit next fit

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 2 K, L <= K <= U, kde představuje: 2 L – nejmenší velikost alokovaného bloku 2 U – 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 2 U. Jestliže platí 2 U-1 < S < 2 U, přidělí se celý blok délky 2 U, jinak se blok rozdělí na dva „blížence“ o rozměrech 2 U-1. Jestliže platí 2 U-2 < S < 2 U-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 2 i - 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 2 i+1 < k < 2 i, nejprve se zkoumá i-seznam a je-li prázdný, zkoumá se (i+1) seznam...

26 Buddy System volná přidělená Req. B – 240K Req. A – 100K

27 Stránkování procesor RAM fyzická adresa logická adresa p p d d f f 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 - 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 Stránkování paměti

29 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: - 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) Segmentace paměti

31 Segment A Segment B Segment C segmentoffset baselimit baselimit baselimit baselimit baselimit baselimit baselimit baselimit fyzická adresa operační paměť

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 ochranu pamě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 Virtuální paměť – zjednodušený princip Logická stránka 0Fyzická stránka 0 Logická stránka 1 Logická stránka 2 Logická stránka 6 Logická stránka 3 Logická stránka 4 Logická stránka 5 Fyzická stránka 1 Fyzická stránka 2 Fyzická stránka 3 Fyzická stránka 4 Fyzická stránka 5 ? - logická adresa, účastní se překladu, leží v adresovém prostoru - fyzická adresa, leží v OP, platná po překladu adres - logické stránky reprezentují 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 a uloží 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 Algoritmy určení oběti 2 2 222 3 22444222 2152453252 33333333333 155555555 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 2 2 222 3 22223333 2152453252 33355555555 111444222

35 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 2 2 22* 3 2 2 2152453252 3335555*55 111443333 2 2 222 3 55553333 2152453252 33332222255 111444442

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 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) P1P1 P2P2 událost zpráva P1P1 P2P2 D

39 Uváznutí - množina procesů P uvázla, pokud každý proces P i 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 Uváznutí a stárnutí procesů Důsledkem snahy synchronizovat běh procesů je jejich uváznutí a stárnutí.

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

41 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í P 0 while(1) { while(obsazeno) ; obsazeno=1; KS; obsazeno=0; } P 1 while(1) { while(obsazeno) ; obsazeno=1; KS; obsazeno=0; } shared int obsazeno=0;

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 #include /****************************** 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() } - 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)

45 Služba WAIT Služba SIGNAL - 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í - 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 #include /******************************* 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; } hodnota se zvýší o 1, pokud je výsledek záporný nebo roven 0, převede se proces pomocí služby ready do prioritní fronty (z fronty semaforu)

47 PRODUCENTKONZUMENT - 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) Synchronizace P-K obecným semaforem

48 Kód producentaKód konzumenta 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(); } - pomocí implementace obecných semaforů se zajistí efektivní fungování mezi konzumentem a producentem - 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 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 R i má W i 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 proces prostředek se čtyřmi instancemi A B P1P1 P2P2 požadavek V držení požadavek

50 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 P1P1 P3P3 P2P2 Neobsahuje cyklus P1P1 P3P3 P2P2 Obsahuje cyklus R1R1 R2R2 R3R3 R4R4 R1R1 R2R2 R3R3 R4R4

51 Prevence uváznutí - konzervativní politika, omezuje se přidělování prostředků, přímé a nepřímé metody - nepřímé metody – zneplatnění některé nutné podmínky (virtualizace prostředků, přidělení všech prostředků najednou, odebírání prostředků) - přímé metody – nepřipuštění platnosti postačující podmínky (uspořádání pořadí přidělování prostředků) - virtualizace – nepřímá metoda, rušení vzájemné výlučnosti, mimo spooling nepoužitelné - požadování všech prostředků najednou – nepřímá metoda, při žádosti o prostředek nesmí proces nic vlastnit, nebezpečí stárnutí procesu, vhodné pro procesy s jednou nárazovou činností, neefektivní, možná prodleva při zahájení procesu - odebírání prostředku – jen když lze uchovat stav prostředku (odebírání procesoru, paměti), ruší se vlastnost nepředbíhatelnosti procesů při používání prostředku, dvě možnosti (odmítnutý proces uvolní vše co vlastní a požádá o vše znovu, pokud požadovaný prostředek vlastní jiný proces, je tento požádán o uvolnění všeho a o znovupožádání o vše), použitelné pro prostředky s uchovatelným a obnovitelným stavem, režijní ztráty, možnost cyklického restartu - preventivní metody jsou jednoduché, neefektivní

52 1 2 3 0 4 5 6 7 8 Uspořádané prostředky volný prostředek proces 5487 proces 1136 proces 25 - proces 5487 nemůže být zablokován, může žádat pouze o prostředek 0, 1 nezablokovatelný - hierarchická strategie se často kombinuje se strategií úplného vyhraze- ní (na jedné úrovni nebývá jeden prostředek, ale celá skupina - stále příliš defenzívní, lze zlepšit vhodnou volbou posloupnosti pro- středků Princip hierarchického uspořádání prostředků

53 Obcházení uváznutí - zamezuje současné platnosti nutných podmínek - připouští se tak více souběžnosti než při prevenci - dva přístupy – nespustí se proces, jehož požadavky by mohly vést k uváznutí, neprovede se přidělení prostředku, pokud by to mohlo vést k uváznutí - prostředky jsou podle svého typu rozděleny do kategorií - každý typ prostředku se vyskytuje v jistém počtu exemplářů, rozdělení závisí na konfiguraci systému (tiskárny podle kvality tisku, disky podle rychlosti, různé komunikační kanály, …) - musí se znát maximum požadovaných prostředků každého procesu, aby mohl proces existovat, musí deklarovat předem svoje C(j, i)

54 Obcházení uváznutí existující prostředky požadované prostředky počet přidělených prostředků typu i procesu j pro všechny typy prostředků i a procesy j souhrnný počet dostupných prostředků typu i počet prostředků typu i potřebných pro dokončení procesu j nový proces smí vzniknout jen když platí souhrnný počet nevyžádaných prostředků typu i

55 Obcházení uváznutí - nejvýhodnější je nalezení strategie, která by neomezovala, dokud se neobjeví nebezpečí zablokování, přidělení prostředku je pozastaveno až do okamžiku, kdy se situace zlepší - bankéřův algoritmus - název úlohy ze situace v reálném světě (bankéř přidělující finanční prostředky v různých měnách, podmínkou je znalost maximálních požadavků zákazníků - operační systém zná požadavky procesů na čerpání prostředků) - pokud existuje alespoň jedno pořadí požadavků, při kterém nedojde k zablokování (všichni klienti banky budou moci splnit své záměry), může operační systém toto pořadí vynutit selektivním splňováním požadavků - bankéř prostředek přidělí, pokud systém po přidělení zůstane v bezpečném stavu - proces vznikne jen tehdy, když lze uspokojit všechny jeho požadavky (v jakémkoli pořadí)

56 Detekce zablokování - liberální politika, každý dostává co chce a kdy chce, existenci uváznutí periodicky testuje operační systém - výhoda: žádný proces nemusí čekat na své zahájení, nevýhoda: nutnost řešit uváznutí a posteriori - řešení: zrušení všech uváznutých procesů (nejčastěji použitá metoda), návrat uváznutých procesů k poslednímu kontrolnímu bodu (možnost opakování situace), postupně rušit uváznuté procesy (podle spotřebovaného času procesoru, podle času do dokončení procesu, podle priority, podle množství vlastněných prostředků), postupně předbíhat uváznuté procesy

57 Správa I/O zařízení (periferií) - vstupní a výstupní zařízení - od notoricky známých až po zbraně, traktory, obráběcí stroje, vlhkoměry, … - řízení periferií pomocí speciálních I/O obvodů - kanálů, jedná se o komunikaci s jiným procesorem - hlavním úkolem operačního systému není přímé ovládání periferie, ale její korektní přidělování jednotlivým procesům, služby pro manipulaci s periferií jsou na daleko vyšší úrovni, než jakou nabízí samo zařízení, sdílení a ochrana zařízení - tyto služby nemusí být součástí operačního systému, mohou být soustředěny ve sdílených knihovnách - rozeznáváme zařízení: vyhrazená, sdílená, společná - vyhrazená: nemohou sloužit více procesům současně, pro každé takové zařízení je potřeba správce, který využívá různých technik

58 Správa I/O zařízení (periferií) Vyhrazená zařízení - vyhrazování zařízení - základní a nejjednodušší mechanismus, správce nedovolí používat zařízení nikomu, pokud je první proces neuvolní - zařízení bývají přidělována podle pořadí požadavků, jedná se o obdobu binárních semaforů v kritických sekcích, jednoduché s vysokou pravděpodobností zablokování - virtualizace - přesvědčení procesu, že má k dispozici neomezený počet vyhrazených zařízení (prakticky existuje omezení velikostí odkládacího prostoru), každý proces potom může dostat svoje zařízení - zařízení se přidělí systémovému procesu (serveru), který je bude ovládat a nabízet svým klientům (ostatním procesům), pro obrazovku zvláštní okno, zvukový výstup promíchán, pro tiskárnu se použije spooling (speciální soubor na disku), virtualizaci nemá význam používat pro její náročnost u málo frekventovaných zařízení

59 Sdílená zařízení - svoji kapacitu mohou dělit na části a každá z nich je k dispozici jinému procesu, není je potřeba vyhrazovat, ale je potřeba správce, který je bude rozdělovat a starat se o přidělování jednotlivých částí Společná zařízení - mohou sloužit bez jakéhokoliv problému více procesům, při vhodné technické realizaci nepotřebují správce (hodiny, mikrofon, …), pokud správce je, je velice triviální, pokud má zařízení nabízet širší služby, je třeba vytvořit server pro správu tohoto zařízení, které se potom chová jako vyhrazené (možnost virtualizace) - hlavním úkolem správce zařízení je starat se o jeho přidělení jednotlivým procesům, nikoliv jeho přímým ovládáním - procesy neovládají samy zařízení: zařízení je ovládáno serverem nebo je virtualizováno, vyšší ovládání zařízení pomocí sdílených knihoven Správa I/O zařízení (periferií)