4. konzultace (5 hodin) 1. dubna 2016

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()

vytvoření PCB procesu: identifikace procesu 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)

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(); - 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

označení stavu procesu 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

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

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í

jestliže není stav SUSPEND, tak chyba 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

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

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;

odstraní proces ze systému, musí existovat 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)

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();

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(); }

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ěť

Cache paměť CPU Word Transfer - drahá a velmi rychlá 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

Adresové prostory RAM LAP FAP procesor RAM DAT - MMU lan la1 la0 DAT - MMU fan fa1 fa0 Logický adresový prostor Fyzický 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)

Relokace v multiprogramovém prostředí je paměť sdílená více procesy, umístění programů v paměti je nezávislé na programátorovi, při odkládání procesů se uplatní relokace před relokací se používalo zobrazení LAP do FAP pomocí identity (monotaskové OS, DAT neexistuje, statický způsob (kompilace-sestavení-zavedení), overlays, programátorsky složité Process control information Process control block Entry point to program Program Branch instruction Increasing address values Data Reference to data Current top of stack Stack

Zobrazení LAP do FAP relokací LAP OS LAP2 LAP1 AP2 AP1 FAP nevyužito RR 0 1000 1200 - zachování spojitosti LAP ve FAP - DAT – relokační registr RR - obraz RR je součástí PCB - LAP -> FAP se provádí dynamicky za běhu

Hardwarová podpora relokace Relative address Process control block Base register Program Adder Absolutní adresa Data Comparator Bounds register Stack Interrupt to operating system Process image in main memory

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ů.

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í)

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

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

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 8 MB 2 MB 4 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ů

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

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 OS proces 5 proces 8 proces 2 volné proces 9 proces 10

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

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 ...

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

Stránkování RAM procesor fyzická adresa logická adresa p d 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)

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

Příklady stránkování A0 1 A1 2 A2 3 A3 4 B0 D0 5 B1 D1 6 B2 D2 7 C0 B1 5 B2 6 C0 7 8 9 10 D3 11 D4 12 D0 D1 D2 Proces A - Proces B Proces C 13 14 Proces D Free frame list - 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

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)

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

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

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á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 Logická stránka 0 Fyzická 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 ?

Stránkovací mechanismus Překlad adres - stránkování Page Offset Virtuální adresa Frame Fyzická adresa + Page table ptr page frame Program Stránkovací mechanismus Operační paměť n bitů m bitů Registr Page table

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 2 3 4 1 5 2 3 1 5 4 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

Algoritmy určení oběti 2 3 5 1 4 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 2 2* 3 1 5 4 5* "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

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

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

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 P1 P2 D 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) P1 P2 událost zpráva

Vliv kritické sekce void echo() { chin = getchar(); chout = chin; putchar(chout); } Proces1 ... chin = getchar(); chout = chin; putchar(chout); Proces2 ... chin = getchar(); chout = chin; putchar(chout);

Požadavky na řešení problému kritických sekcí Vzájemné vyloučení (podmínka bezpečnosti) – Mutual Exclusion Pokud proces Pi je ve své kritické sekci, pak žádný další proces nesmí být ve své kritické sekci sdružené s týmž prostředkem. V každém okamžiku smí být v kritické sekci pouze jeden proces. Trvalost postupu (podmínka živosti) – Progress Rozhodování o tom, který proces vstoupí do KS, ovlivňují pouze procesy, které o vstup do kritické sekce usilují. Toto rozhodnutí pro žádný proces nemůže být odkládáno do nekonečna (nedodržení této podmínky může vést ke striktní alternaci dvou procesů). Konečné čekání (podmínka spravedlivosti) – Fairness Proces smí čekat na povolení vstupu do kritické sekce jen konečnou dobu. Musí existovat omezení počtu, kolikrát může být povolen vstup do KS sdružené s jistým prostředkem jiným procesům než procesu požadujícímu vstup v době mezi vydáním žádosti a jejím uspokojením. Pokud tedy proces usiluje o vstup do KS, nemohou tomu ostatní procesy zabránit tím, že se v kritické sekci neustále střídají (vstupují do ní zpravidla jednou).

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

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

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

HW řešení kritické sekce Proces Pi do { disable interrupt KS enable interrupt ZP } while (1); - na monoprocesoru se dosáhne vzájemného vyloučení - snižuje se efektivnost (nelze prokládat běh procesu v KS a procesů v ZP) - na multiprocesoru se vzájemného vyloučení nedosáhne - obecně neakceptovatelné řešení - řešení speciálními instrukcemi, atomicky se provádí dvě akce se stejnou buňkou paměti (čtení a testování, výměna registrů) - akce jsou výlučné i v prostředí multiprocesoru - složitější algoritmy - je splněna podmínka bezpečnosti, vzájemné vyloučení, druhý proces aktivně čeká - není splněna podmínka konečnosti čekání, může dojít ke stárnutí, volba dalšího procesu v KS je náhodná testset(i) je-li i==0, i=1 vrací true je-li i==1 vrací false Proces Pi do { do {} while testset(b); KS b=0; ZP while(1);

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í)

Obecný semafor Typ SEMAPHOR - 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

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() }

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í Služba SIGNAL 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í

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 do prioritní 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; }

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) PRODUCENT KONZUMENT

- 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

Modelování uváznutí A P2 P1 B - 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 proces prostředek se čtyřmi instancemi A B P1 P2 požadavek V držení

Ochrana před uváznutím Neobsahuje cyklus Obsahuje cyklus R1 R2 R3 R4 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

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í

Princip hierarchického uspořádání prostředků 1 2 3 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ů

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)

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

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í)

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

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

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í

Správa I/O zařízení (periferií) 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

Platformy rozhraní Win32 API - API - Application Programming Interface, množina funkcí - implementace na platformách: Win32s - mapovací vrstva z 32 b. na 16 b., pro Windows 3.x, používá mechanismus roubování (thunking), konvertuje 32 b. parametry na 16 b., platforma Win32s nerozšiřuje možnosti operačního systému, řada funkcí je realizována jako slepé (stub) - hned se vrátí a hlásí chybu (16 b. Win nepodporují toky -> funkce CreateThread vrací NULL), některá rozšíření (strukturovaná obsluha výjimek, částečná implementace paměťově mapovaných souborů), vytvořena pro vytváření 32 b. aplikací ještě před příchodem oficiální platformy, nijak zvlášť se neujala. Windows NT (Win 32 pro 64 bitů) platforma s výhledem do budoucnosti, žádné pozůstatky z MS DOSu, značné nároky na velikost paměti a disku, velice robustní, brání přímému přístupu k HW počítače, přenositelnost (C++, MIPS, Alpha, PowerPC) – potřeba překladu pro daný procesor, jádro a HAL (Hardware Abstraction Layer) je potřeba přepsat speciálně pro jinou architekturu (assembler), podpora více procesorů. Windows 95 (Windows 98) - první 32 b. platforma s širokým použitím, lepší implementace Win32 API než Win32s (nikoliv úplná), HW nedostatečný pro Windows NT, omezená podpora pro funkce bezpečnostní, sledování událostí, ladící, pro práci s registry, velmi přijatelná a výkonná. Windows CE - pro kapesní počítače, bez podpory virtuální paměti, podpora paměťově mapovaných souborů, strukturovaná obsluha výjimek, registry, DLL, preemptivní multitasking, přenositelná.