Post on 04-Jan-2016
description
9. přednáška17. 4. 2014
- srovnání plánovacích politik- fronty- služby správce procesů (resched, ready, resume, suspend, kill, sleep, wakeup)
Studijní materiály najdete na adrese:
http://www.uai.fme.vutbr.cz/~vdumek/
Srovnání plánovacích politik – použité procesy
Process Arival Time Service Time
A 0 3
B 2 6
C 4 4
D 6 5
E 8 2
Srovnání plánovacích politik0 5 10 15 20
ABCDE
ABCDE
ABCDE
ABCDE
ABCDE
ABCDE
FCFS
RR q=1
RR q=4
SPN
SRT
Feedbackq=1
Process
Arrival Time
Service Time (Ts)
A
0
3
B
2
6
C
4
4
D
6
5
E
8
2
Průměr
FCFS
Finish Time
Turnaround Time (Tr)
Tr/Ts
3
3
1,00
9
7
1,17
13
9
2,50
18
12
2,40
20
12
6,00
8,60
2,65
RR q=1
Finish Time
Turnaround Time (Tr)
Tr/Ts
4
4
1,33
18
16
2,67
17
13
3,25
20
14
2,80
15
7
3,50
10,80
2,71
RR q=4
Finish Time
Turnaround Time (Tr)
Tr/Ts
3
3
1,00
17
15
2,5
11
7
1,25
20
14
2,80
19
11
5,50
10,00
2,71
SPN
Finish Time
Turnaround Time (Tr)
Tr/Ts
3
3
1,00
9
7
1,17
15
11
2,75
20
14
2,80
11
3
1,50
7,60
1,84
SRT
Finish Time
Turnaround Time (Tr)
Tr/Ts
3
3
1,00
15
13
2,17
8
4
1,00
20
14
2,80
10
2
1,00
7,20
1,59
FB q=1
Finish Time
Turnaround Time (Tr)
Tr/Ts
4
4
1,33
20
18
3,00
16
12
3,00
19
13
2,60
11
3
1,5
10,00
2,63
FCFS (First Come First Served) – nejdéle čekající proces z připravených, nonpreemptive, proces se musí ukončit sám (zvýhodnění procesorově orientovaných), snadná implementaceRound Robin (cyklické plánování) – výběr stejný jako u FCFS, nonpreemptive, předem stanovené kvantum (desítky ms, při delším kvantu degradace na FCFS), favorizuje procesorově vázané, virtuální RR (pomocná fronta obsluhovaná prioritně, procesy běží pouze po zbytek časového kvanta), prioritní RRSPN (Shortest Process Next) – proces s nejmenší očekávanou dobou potřeby procesoru, nonpreemptive, varianta SRT (Shortest First) preemptivní, jakmile se objeví kratší, dojde k přerušení, zvýhodnění V/V vázaných procesů, problém odhadu potřeby procesoru, exponenciální průměrování (aproximace budoucnosti z historie, přednost novým procesům), znevýhodnění dlouhých procesůFeedback (zpětná vazba) – neznáme délky procesů, penalizace dlouho běžících procesů, pro každou prioritu jedna fronta, výběr pomocí RR, poslední fronta pomocí FCFS
Srovnání plánovacích politik
- správce procesů (dispečer, plánovač) sleduje procesy v systému a řídí jejich chování, předává jim procesor
- správce procesů plánuje, který proces bude aktivován, rozhoduje o přerušení aktivního procesu
- příští aktivní proces určuje plánovací algoritmus
- pro zajištění činnosti udržuje správce procesů několik front procesů, odpovídajících jednotlivým situacím, ve kterých proces na něco čeká
- ve frontách čekají procesy na ukončení určité situace
- z fronty se vybírá proces podle splnění určitých kritérií, aktivace po odstranění příčiny čekání
- zabraňuje monopolizování procesoru procesem
Operační systém, to je něco jako socialistická ekonomika: samé plánování a samá fronta. (Roderik Plevka)
Správa procesů
- práce s frontami - základní požadavek efektivity správce procesů- fronta je objekt, na který můžeme aplikovat služby:
* vytvoření fronty - vznik nového objektu* zrušení fronty * umístění do fronty - vložení na určité místo fronty* odebrání z fronty - vrací proces z fronty (první, obecný)
- správce front udržuje několik prioritních front, jednu frontu speciál- ního typu - delta list, fronty typu FIFO- prioritní fronta - parametrem je priorita procesu, podle které se pro- cesy řadí sestupně, proces je zařazen na konec skupiny procesů se stejnou prioritou- delta list - fronta, do které se procesy řadí pro čekání na uplynutí ča- sového intervalu- absolutní čas je pouze u prvního procesu, jinak přírůstky- FIFO – First In First Out, LIFO – Last In First Out
Fronty procesů
Typy front
Prioritní
P = 1
P = 1
P = 4
P = 6
P = 6
P = 6
P = 10
P = 10
P = n
…..
1
4
6
10
n
Delta list
t = 16
…..
18
697
1580
12358
první
FIFO
poslední
LIFO
poslední první
Fronta jako spojový seznam
- žádný proces nemůže být ve více frontách současně, zpětně vázaný seznam (v každém prvku vyjma prvního a posledního je umístěn ukazatel na předcházející a následující prvek)
NULLnásledující
PID
předchozí
následující
PID
předchozí
NULL
PID
První člen Poslední člen
. . . . .
isempty() /* je fronta prázdná ? */nonempty(q) /* je fronta neprázdná ? */firstkey(q) /* nejmenší priorita ve frontě */lastkey(q) /* největší priorita nebo čas v delta listu*/firstid(q) /* první proces ve frontě */
enqueue(p,q) /* zařazení procesu p na konec fronty q */insert(p,q,key) /* zařazení s prioritou key */insertd(p,q,time) /* zařazení do delta listu */dequeue(p) /* odstranění procesu p z fronty */getfirst(q) /* zjištění prvního procesu ve frontě */getlast(q) /* zjištění posledního procesu ve frontě */newqueue(void) /* vytvoření nové fronty */
Správa front
suspended
ready current
waiting
receiving
sleeping
Stavy procesů
Situace, kdy jsou všechny procesy mimo pohotovostní stav (ready), jediný aktivní proces potřebuje přerušit (čekání na stisk klávesy) - proces s nízkou prioritou, triviální obsah, nesmí být v jiném stavu než ready nebo current
Nulový proces
- suspended: speciální stav procesů, z/do něj se dostane pouze na základě explicitního požadavku jiného procesu nebo OS- ready: čekání na přidělení procesoru, ready (prioritní) fronta, vybírá se první proces- current: aktivní stav, pouze jeden proces, při ukončení změna kontextu- waiting: čekání na periferní operaci, každá událost má svoji frontu- receiving: čekání na příchod zprávy od jiného procesu- sleeping: čekání na uplynutí časového intervalu, delta list
z kteréhokoliv stavu lze proces zrušit, při rušení aktivního procesu se mění kontext- změna kontextu - základní kámen multitaskingu, plánování činnosti procesů
Stavy procesů
suspended
ready current
waiting
receiving
sleeping
create
suspendresume
resched
signal wait
send receive
wakeup sleep
Služby správce procesů Vlastní přepnutí kontextu je „zabaleno“ do resched
blocked
Komunikace se servery
Využívají ovladače periferií
Tabulka procesů (demonstrační verze)
#define PRNEW '\011' /* proces byl vytvořen */#define PRCURR '\01' /* proces právě běží */#define PRFREE '\02' /* volné místo v tabulce procesů */#define PRREADY '\03' /* proces je v ready frontě */#define PRRECV '\04' /* proces čeká na zprávu */#define PRSLEEP '\05' /* proces čeká na uplynutí času */#define PRSUSP '\06' /* proces je suspendován */#define PRWAIT '\07' /* proces čeká na semafor */struct pentry { unsigned char pstate; /* stav procesu: PRCURR, ... */ short pprio; /* priorita */ unsigned *svarea; /* ukládací oblast pro kontext */ short psem; /* semafor pro stav waiting */ short pmsg; /* přijatá zpráva */ short phasmsg; /* <> 0, je-li zpráva OK */ unsigned *pbase; /* zásobník */ unsigned pstklen; /* jeho délka */ unsigned *plimit; /* jeho limit */ char pname[PNMLEN]; /* jméno procesu */ short pargs; /* počet parametrů */ void *paddr; /* startovní adresa */};extern struct pentry proctab[];
- v tabulce procesů se udržují potřebné i nepotřebné informace o procesech, (jméno, čas vytvoření, způsob vytvoření, …), statistické a ladící účely
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