4. konzultace (4 hodiny)28. 3. 2014

Studijní materiály najdete na adrese:

http://www.uai.fme.vutbr.cz/~vdumek/

vstupní bod funkce

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

Implementace služby CREATE (demonstrační verze)

vytvoření záznamu na zásobníku

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.

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

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

- 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 <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 1RESCHNO definováno jako 0

Implementace služby READY

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

Implementace služby RESUME

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

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

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

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

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

- 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

Implementace služby WAKEUP

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

- 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

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

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

lan

la1

la0

DA

T -

MM

U

fan

fa1

fa0

Logický adresový prostor Fyzický adresový prostor

LAP - logické adresy, instrukční soubor procesoruFAP - fyzické adresy, HW řešeníDAT - Dynamic Address TranslationMMU - Memory Management Unitspráva adresových prostorů (oddělení LAP a FAP pro jednotlivé procesy, rozdělení FAP pro LAP)

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

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ířeInterní 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í

P4

P4P3

P1

P3

P2

P2

P1

volná

volná

volná

volná

fragmentovánodefragmentováno

Odstranění fragmentace - setřásá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

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í

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

8 MB

8 MB

8 MB

8 MB

8 MB

8 MB

8 MB

8 MB

2 MB

4 MB

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

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

8 MB

12 MB

16 MB

novéprocesy

novéprocesy

8 MB

2 MB

4 MB

8 MB

8 MB

12 MB

16 MB

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 10volné

volné

Blokové přidělování - dynamické

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 fragmentaciBest 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žadavkyWorst fit – přidělí oblast v největší díře, pomalá, zanechává největší díruLast 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

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 bloku2U – 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

volná

přidělená

Req. B – 240K

Req. A – 100K

1M

1M

512K

512K

512K

512K

B - 256K

256K

B - 256K

B - 256K

256K

256K

256K

256K

D - 256K

D - 256K

D - 256K 256K

256K

256K

256K

256K

256K

128KE - 128K

E - 128K

128K

A - 128K

A - 128K

A - 128K

A - 128K

A - 128K 128K

128K

C 64K 64K

C 64K 64K

C 64K 64K

C 64K 64K

C 64K 64K

Rel. B

Req. E – 75K

D - 256K

D - 256K

D - 256K

Req. D – 256K

Req. C – 62K

Rel. A

Rel. C

Rel. E

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)

- 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

Příklady stránkování

A11

A22

A33

B04

A00

B15

B26

C07

C08

C09

C010

D311

D412

D04

D15

D26

0 0

1 1

2 2

3 3

Proces A

0 -

1 -

2 -

Proces B

0 7

1 8

2 9

3 10

Proces C

13

14

0 4

1 5

2 6

3 11

Proces D

4 12

13

14

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

Segmentace paměti

Segment A

Segment B

Segment C

segment offset

base limit

base limit

base limit

base limit

base limit

base limit

base limit

base limit

fyzická adresa

operační paměť

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

?

- 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

Algoritmy určení oběti

2

2

2 2 2

3

2 2 4 4 4 2 2 2

2 1 5 2 4 5 3 2 5 2

3 3 3 3 3 3 3 3 3 3 3

1 5 5 5 5 5 5 5 5

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

2 2 2

3

2 2 2 2 3 3 3 3

2 1 5 2 4 5 3 2 5 2

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

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

2 2* 2*

3

2 2* 2* 2* 2 2* 2* 2*

2 1 5 2 4 5 3 2 5 2

3 3 3 5 5 5 5* 5 5 5* 5*

1 1 1 4 4 3 3 3 3

2

2

2 2 2

3

5 5 5 5 3 3 3 3

2 1 5 2 4 5 3 2 5 2

3 3 3 3 2 2 2 2 2 5 5

1 1 1 4 4 4 4 4 2

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

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 P2událost

zpráva

P1 P2D

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

Uváznutí a stárnutí procesů

Důsledkem snahy synchronizovat běh procesů je jejich uváznutí a stárnutí.

proces A

proces B

proces C

proces D

W

X

YV

NESMÍ NASTAT

Vznik uváznutí procesů

Možnosti řešení problému kritické sekce

Softwarové řešení aktivní čekání, naivní řešení, myšlenkazamykacích proměnných není zcelachybná

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émupotř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

while(1) { while(obsazeno) ; obsazeno=1; KS; obsazeno=0;}

shared int obsazeno=0;

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

- 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

#include <conf.h>#include <kernel.h>#include <proc.h>#include <q.h>#include <sem.h>/******************************WAIT - převede aktuální procesdo 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)

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í

Implementace služby SIGNAL

#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;}

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)

PRODUCENT KONZUMENT

- 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

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

}

- 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

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

proces

prostředek se čtyřmiinstancemi

A

B

P1

P2

požadavek

V držení

V držení

požadavek

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

P1 P3P2

Neobsahuje cyklus

P1 P3P2

Obsahuje cyklus

R1

R2

R3

R4

R1

R2

R3

R4

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í

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ů

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í

)(iR

),( ijC

),( ijA

),(),(),( ijAijCijN

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

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

j

ijAiRiV ),()()(

j

ijCiRiU ),()()(

)(),( iUijC

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í

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