Esercitazione di Sistemi Operativi

Esercizio 1: Scheduling
Esercitazione di
Sistemi Operativi
In un sistema time−sharing con priorità sono presenti 4 processi P1−
P4: P1 in esecuzione; P2 pronto; P3 e P4 in attesa su operazione di
I/O. I processi P1 e P3 hanno uguale priorità, più alta della priorità dei
processi P2 e P3, le cui priorità sono tra loro uguali.
Moreno Marzolla
Università Ca’ Foscari di Venezia
email: [email protected]
Descrivere come cambia lo stato del sistema se, partendo da questa
situazione, si verificano, nell’ordine, gli eventi seguenti:
a. quanto di tempo
b. completamento dell’operazione di I/O per P4
c. il processo in esecuzione chiede una operazione di I/O
d. completamento dell’operazione di I/O per P3
e. quanto di tempo
f. il processo in esecuzione termina
Moreno Marzolla
Scheduling: richiami
"
Nel modello più semplice, ciascun processo può trovarsi
in uno tra cinque stati:
Esercitazione di Sistemi Operativi − 2
Scheduling: richiami (cont.)
"
Il diagramma delle transizioni tra gli stati è il seguente:
Dispatch
"
Nuovo: un nuovo processo che inizia l’esecuzione
"
In Esecuzione: sta usando la CPU
"
Pronto: andrebbe in esecuzione se avesse la CPU
"
In attesa: il processo non può essere eseguito perché è in
attesa di un evento esterno
"
Uscita: un processo che termina l’esecuzione
Moreno Marzolla
Esercitazione di Sistemi Operativi − 3
New
Admit
Ready
Running
Release
Exit
Timeout
Event
Occurs
Event
Wait
Blocked
Moreno Marzolla
Esercitazione di Sistemi Operativi − 4
Scheduling: richiami (cont.)
"
In realtà per svolgere l’esercizio, ci conviene pensare
alla rappresentazione del diagramma precedente come
una rete di code (la versione seguente è semplificata):
Ready prio high
Scheduling: richiami (cont.)
"
Nello scheduling con priorità, quando il SO deve
assegnare la CPU ad un processo pronto, sceglie quello
con priorità più alta tra tutti i processi Ready.
"
All’interno della stessa classe di priorità, lo scheduling è
FIFO.
CPU
Ready prio low
Timeout
Event
Wait
Event
Occurs
Blocked Queue
Moreno Marzolla
Esercitazione di Sistemi Operativi − 5
Moreno Marzolla
Esercitazione di Sistemi Operativi − 6
Soluzione dell’esercizio
"
Situazione iniziale (i
processi sottolineati
hanno priorità più alta):
"
a. quanto di tempo
"
P1 diventa Ready. La CPU
passa a P2
Soluzione (cont.)
"
b. P4 completa I/O
"
P4 diventa Ready.
viene assegnata a P1 perché di
priorità più alta
P2
P1
P2
P4
P3
Moreno Marzolla
c. Il processo in
esecuzione chiede I/O
" P2 diventa Blocked. La CPU
P1
P1
"
P2
P1
P4
P4
P3
P2
P3
P4
P3
Esercitazione di Sistemi Operativi − 7
Moreno Marzolla
Esercitazione di Sistemi Operativi − 8
Soluzione (cont.)
"
d. P3 completa I/O
"
P3 diventa Ready
"
Soluzione (cont.)
e. Quanto di tempo
"
" P1 diventa Ready, e la CPU
viene assegnata a P3 perché di
priorità più alta
P3
P1
f. Il processo in
esecuzione termina
"
La CPU viene assegnata a
P1
P1
P3
P4
P4
P1
P4
P2
P2
P2
Moreno Marzolla
Esercitazione di Sistemi Operativi − 9
Moreno Marzolla
Esercizio 2: Allocazione Risorse
Un sistema batch dispone di 20 lettori di nastri. Al sistema arrivano processi
che richiedono 4 lettori (qualsiasi) per completare. Di questi lettori,
inizialmente ne vengono utilizzati 3, e l’ultimo viene effettivamente utilizzato
solo per un breve periodo prima che il processo termini.
Esercitazione di Sistemi Operativi − 10
Svolgimento
"
Il numero massimo di processi in esecuzione
parallelamente è 20/4 = 5. Ciascun processo avrà 4
lettori di nastri a disposizione.
P1
Considerare il seguente algoritmo di allocazione risorse: un nuovo processo
viene ammesso se ci sono almeno 4 lettori liberi. In tal caso, tutti i 4 lettori gli
vengono assegnati fino alla terminazione. Se non ci sono 4 lettori liberi, il
processo viene messo in attesa. Una volta allocati per un certo processo, i
lettori non possono essere revocati finché il processo non termina.
P2
P3
" In questo scenario, quale è il numero minimo e massimo di lettori di nastri
allocati ma non utilizzati dai processi?
P4
" Sviluppare un algoritmo di allocazione delle risorse che consenta un
migliore utilizzo delle risorse, evitando il deadlock.
P5
Moreno Marzolla
Esercitazione di Sistemi Operativi − 11
Moreno Marzolla
Esercitazione di Sistemi Operativi − 12
Svolgimento (cont.)
"
Nella migliore delle ipotesi, ovvero quando tutti i
processi stanno per concludere e utilizzano 4 lettori
ciascuno, tutti i lettori di nastri saranno impegnati.
"
Nella peggiore delle ipotesi, tutti i processi in
esecuzione potrebbero essere nella fase iniziale, in cui
fanno uso di 3 lettori ciascuno. Quindi in tutto staranno
usando 5x3=15 lettori, e i rimanenti 5 sono inutilizzati
Algoritmo di allocazione alternativo
"
Consideriamo prima un algoritmo che tenta di
massimizare il numero di lettori utilizzati, ma non
funziona:
"
Un nuovo processo viene ammesso se c’è almeno un lettore
libero, ossia non già assegnato ad altri processi
"
Se un processo non riesce ad ottenere almeno 3 lettori,
rimane bloccato finché non gli vengono assegnati i mancanti.
"
"
Moreno Marzolla
Esercitazione di Sistemi Operativi − 13
Notare che nel frattempo continua a trattenere i lettori già
assegnatigli
Quando un processo ottiene 3 lettori, può cominciare ad
operare.
Moreno Marzolla
Perché non funziona
"
Perché non funziona
L’algoritmo precedente può portare a deadlock:
"
"
"
Esercitazione di Sistemi Operativi − 14
P1
6 processi (P1−P6) vengono ammessi, ciascuno richiede (ed
ottiene) 3 dei 4 lettori che servono. I processi iniziano ad
operare. Rimangono 2 lettori liberi
P2
P3
un ulteriore processo (P7) viene ammesso, gli vengono
assegnati i 2 lettori liberi. Nessun ulteriore lettore è disponibile.
Il processo però ne richiede 3 per iniziare ad operare, per cui
rimane bloccato trattenendo i lettori già assegnati.
P4
P5
P1−P6 giungono infine a richiedere un quarto lettore. Nessuno
è disponibile, per cui rimangono bloccati e non liberano le
risorse già acquisite.
P6
P7 (bloccato)
Moreno Marzolla
Esercitazione di Sistemi Operativi − 15
Moreno Marzolla
Esercitazione di Sistemi Operativi − 16
Una possibile soluzione funzionante
"
Ciascun processo viene ammesso se esistono almeno 4
lettori liberi. Altrimenti il processo resta in attesa.
"
Ad ogni nuovo processo ammesso vengono assegnati
inizialmente 3 lettori.
"
In questo modo, al più 6 processi possono essere attivi
contemporaneamente. Questi utilizzeranno almeno 18
lettori di nastri. 2 rimangono liberi.
"
Quando un processo entra nella fase terminale,
richiederà un ulteriore nastro
Moreno Marzolla
Esercitazione di Sistemi Operativi − 17
Esercizio 3
Si consideri un computer multiprogrammato in cui ogni job è identico agli altri.
Ciascun job, in un periodo di computazione T, spende metà tempo in I/O e l’altra
metà usando la CPU. Ogni job viene eseguito per N periodi. Si assuma uno
scheduling round−robin, e che le operazioni di I/O possano essere sovrapposte
con l’uso di CPU. Definiamo le seguenti quantità:
Tempo di turnaround:
tempo complessivo richiesto per completare un job
Throughput:
numero medio di job completati per periodo di tempo T
Utilizzazione della CPU: % di tempo in cui la CPU è attiva (non in attesa)
Calcolare le precedenti quantità nel caso di uno, due e quattro job simultanei, in
ciascuna delle situazioni seguenti:
a. Ogni periodo T è dedicato per la prima metà ad I/O, e per la seconda metà
all’uso di CPU
b. Ogni periodo T è dedicato per il primo e per l’ultimo quarto ad I/O, e nella parte
centrale all’uso di CPU
Moreno Marzolla
Esercitazione di Sistemi Operativi − 18
Soluzione: 1 job
"
Soluzione: 2 job
Consideriamo il caso a.: il processo occupa la prima
metà di ogni periodo T facendo I/O, e la rimanenza
usando la CPU
Job1
I/O
CPU
I/O
T
CPU
T
I/O
CPU
"
Consideriamo il caso a., ricordando che il sistema
consente di sovrapporre l’I/O con l’uso della CPU
Job1
I/O
Job2
T
T
Tempo di turnaround: NT
"
"
"
Throughput: 1/N job completati/periodo
"
Utilizzazione CPU: 50%
"
Moreno Marzolla
Esercitazione di Sistemi Operativi − 19
I/O
CPU
CPU
I/O
I/O
CPU
T
CPU
I/O
CPU
T
Job1 = NT, Job2 = NT + 0.5 T
Throughput: 2/(N+0.5) job completati/periodo
"
Il caso b. è identico
I/O
Tempo medio di turnaround: (NT+NT+0.5T) / 2 = NT+0.25T
"
"
CPU
L’ultimo job finisce dopo (N+0.5) periodi
Utilizzazione CPU: N/(N+0.5)
Moreno Marzolla
Esercitazione di Sistemi Operativi − 20
Soluzione: 2 job
"
Consideriamo ora il caso b.
I/O
Soluzione: 4 job (caso a)
CPU
I/O
CPU
Job1
Job1
Job2
T
"
T
T
Tempo di turnaround: NT+ 0.25T
"
"
T
Job2
Job3
Job1 = NT, Job2 = NT + 0,5T
Throughput: 2/(N+ 0.5) job completati/periodo
Job4
T
"
"
T
T
T
L’ultimo job finisce dopo (N+ 0.5) periodi
I/O
Utilizzazione CPU: N/(N+0.5)
CPU
Moreno Marzolla
Esercitazione di Sistemi Operativi − 21
Moreno Marzolla
Soluzione: 4 job (caso a)
"
"
Esercitazione di Sistemi Operativi − 22
Soluzione: 4 job (caso b)
Tempi di completamento:
I/O
"
Job1=T + 2(N−1)T
= 2NT − T
"
Job2=1,5T + 2(N−1)T
= 2NT − 0.5 T
"
Job3=2T + 2(N−1)T
= 2NT
Job2
"
Job4=2,5T + 2(N−1)T
= 2NT + 0.5 T
Job3
Tempo medio di Turnaround: 2NT − 0.25T
"
Throughput: 4/(2N+0.5) job completati/periodo
"
Utilizzazione CPU: 2N/(2N + 0.5) = N/(N + 0.25)
CPU
Job1
Job4
T
T
T
T
T
T
T
T
T
I/O
CPU
Moreno Marzolla
Esercitazione di Sistemi Operativi − 23
Moreno Marzolla
Esercitazione di Sistemi Operativi − 24
Soluzione: 4 job (caso b)
"
Esercizio 4
Tempi di completamento:
"
Job1=1,25 T + 2(N−1)T
= 2NT − 0,75 T
"
Job2=1,5 T + 2(N−1)T
= 2NT − 0,5 T
"
Job3=2 T + 2(N−1)T
= 2NT
"
Job4=2,5 T + 2(N−1)T
= 2NT + 0,5 T
"
Tempo medio di Turnaround: 2NT −0.1875 T
"
Throughput: 4/(2N + 0,5) job completati/periodo
"
Utilizzazione CPU: 2N/(2N + 0,5) = N/(N + 0,25)
Moreno Marzolla
Esercitazione di Sistemi Operativi − 25
Il calcolatore CDC6600 poteva gestire fino a 10 processi
contemporaneamente utilizzando una forma di Round Robin
chiamata Processor Sharing. Un process switch avveniva ad
ogni istruzione, così che la prima istruzione eseguita
apparteneva al processo 1, la successiva al processo 2 e così
via. Il process switch era gestito via hardware con overhead
pari a zero. Se un processo richiedeva T secondi per terminare
in assenza di competizione per la CPU, quanto tempo avrebbe
richiesto se il processor sharing veniva attuato con n processi in
totale?
Moreno Marzolla
Soluzione
"
"
Esercitazione di Sistemi Operativi − 26
Soluzione (cont.)
È sufficiente osservare che il Processor Sharing
equivale a Round Robin con quanto di tempo "quasi"
zero.
Quale sarebbe la risposta se considerassimo uno
scheduling Round Robin con quanto di tempo pari a Q
secondi?
Processo
"
A ciascun processo servono T/Q quanti di tempo,
ciascuno di durata Q, per terminare.
"
Se un processo riceve un quanto a partire dal tempo T0,
il suo prossimo quanto inizierà al tempo T0+nQ
"
In tutto, per eseguire tutti i processi servono (nQ)(T/Q) =
nT secondi (indipendente dal valore di Q).
"
Pertanto, anche nel caso del Processor Sharing, il
tempo richiesto ad eseguire un processo sarà nT
secondi
Tempo
Q
nQ
Moreno Marzolla
Esercitazione di Sistemi Operativi − 27
Moreno Marzolla
Esercitazione di Sistemi Operativi − 28
Esercizio 5
RR con Quanto=1min
Cinque processi, A−E, arrivano alla CPU quasi contemporaneamente. Il loro
tempo di esecuzione stimato è rispettivamente 10, 6, 2, 4 e 8 minuti. Le loro
priorità sono risp. 3, 5, 2, 1 e 4 (5 è la priorità massima). Per ciascuno degli
algoritmi di scheduling seguenti, determinare il tempo medio di
completamento per processo. Ignorare ogni overhead causato dal context
switch:
a) Round Robin (quanto di 1min e 2min);
b) Priority Scheduling;
c) First Come First Served (FCFS, l’ordine di esecuzione è A−B−C−D−E);
d) Shortest Process Next (SPN)
Nel caso a) assumere un sistema multiprogrammato, in cui ogni job riceve
una quota equa di CPU. Nei casi da b) a d) assumere che un solo processo
alla volta sia in esecuzione finché termina. Tutti i processi sono CPU bound.
Moreno Marzolla
Esercitazione di Sistemi Operativi − 29
E (8)
D (4)
C (2)
B (6)
A (10)
T (min)
5
10
15
20
25
30
"
Tempi di complet.: TC=8, TD=17, TB=23, TE=28 TA=30
"
Tempo medio di completamento:
(8 + 17 + 23 + 28 + 30) / 5 = 21,2 minuti
Moreno Marzolla
Esercitazione di Sistemi Operativi − 30
RR con Quanto=2min
Priority Scheduling
E (4/8)
D (1/4)
C (2/2)
B (5/6)
A (3/10)
E (8)
D (4)
C (2)
B (6)
A (10)
T (min)
5
10
15
20
25
T (min)
30
5
10
15
20
25
30
"
Tempi di complet.: TC=6, TD=16, TB=22, TE=28, TA=30
"
Tempi di complet.: TA=24, TB=6, TC=26, TD=30, TE=14
"
Tempo medio di completamento:
(6 + 16 + 22 + 28 + 30) / 5 = 20,4 minuti
"
Tempo medio di completamento:
(24 + 6 + 26 + 30 + 14) / 5 = 20 minuti
Moreno Marzolla
Esercitazione di Sistemi Operativi − 31
Moreno Marzolla
Esercitazione di Sistemi Operativi − 32
FCFS
SPN
E (8)
D (4)
E (8)
D (4)
C (2)
B (6)
A (10)
C (2)
B (6)
A (10)
T (min)
5
10
15
20
25
T (min)
30
5
10
15
20
25
30
"
Tempi di complet.: TA=10, TB=16, TC=18, TD=22, TE=30
"
Tempi di complet.: TC=2, TD=6, TB=12, TE=20, TA=30
"
Tempo medio di completamento:
(10 + 16 + 18 + 22 + 30) / 5 = 19,2 minuti
"
Tempo medio di completamento:
(2 + 6 + 12 + 20 + 30) / 5 = 14 minuti
Moreno Marzolla
Esercitazione di Sistemi Operativi − 33
Moreno Marzolla
Osservazione su SPN
"
"
"
Tabella riassuntiva
SPN ha fornito il minor tempo medio di turnaround. È
possibile dimostrare che questo è vero in generale.
Supponiamo di avere 3 processi, che richiedono risp.
tempo T1 < T2 < T3 per completare.
Algoritmo
Tempo medio di
Turnaround
RR (Quanto=1min)
21.2
Calcoliamo il tempo medio di turnaround
RR (Quanto=2min)
20.4
Priority Scheduling
20
"
"
Esercitazione di Sistemi Operativi − 34
( T1 + (T1+T2 ) + (T1+T2+T3 ) ) / 3 = ( 3T1 + 2T2 + T3 ) / 3
FCFS
SPN
Nella sommatoria, il tempo che compare col fattore più
alto è T1, che è il tempo minore. Il tempo più elevato
19.2
14
contribuisce alla somma col fattore più piccolo.
Moreno Marzolla
Esercitazione di Sistemi Operativi − 35
Moreno Marzolla
Esercitazione di Sistemi Operativi − 36
Esercizio 6
Misure compiute su un certo sistema hanno mostrato che un
processo mediamente usa la CPU per un tempo T prima di
bloccarsi su un I/O. Un process switch richiede tempo S
(overhead). Considerando uno scheduling Round Robin con
quanto Q, dare una formula per l’efficienza della CPU (frazione
di tempo dedicata ai processi) per ciascuno dei casi seguenti:
"
In questo caso ogni processo non viene mai interrotto, e
il context switch avviene solo ogni T, quando il processo
in esecuzione si blocca su I/O.
Kernel
P3
P2
a) Q=∞
b) Q>T
c) S<Q<T
d) Q=S
e) Q quasi zero.
Moreno Marzolla
Caso a) Q=∞
P1
T
"
Esercitazione di Sistemi Operativi − 37
Questo caso è equivalente al precedente
"
"
T
S
T
S
tempo
Efficienza: T / ( T + S )
Moreno Marzolla
Caso b) Q>T
"
S
Esercitazione di Sistemi Operativi − 38
Caso c) S<Q<T
"
Un processo non ha ancora consumato il suo quanto di tempo
Q quando si blocca su I/O. Quindi avviene un context switch
ogni T.
In questo caso avviene uno o più context switch prima
del blocco del processo su I/O.
"
Ciascun processo necessita di circa T/Q quanti di tempo di
durata Q prima di bloccarsi su I/O
L’efficienza è ancora T / ( T + S )
Kernel
P2
P1
Q
"
Moreno Marzolla
Esercitazione di Sistemi Operativi − 39
S
Q
S
tempo
Efficienza (approssimata):
Q / ( Q + S ) > 0.5
Moreno Marzolla
Esercitazione di Sistemi Operativi − 40
Caso d) Q=S
"
Caso e) Q quasi 0
In questo caso avviene uno o più context switch prima
del blocco del processo su I/O.
"
"
In particolare, avvengono in tutto circa T/Q context switches.
Se il quanto è troppo breve, si può immaginare che il
sistema spenda quasi tutto il tempo ad eseguire context
switches:
Kernel
Kernel
P2
P2
P1
P1
Q
"
S
Q
"
Efficienza (approssimata):
Q / ( Q + S ) = S / 2S = 0.5
Moreno Marzolla
Q
tempo
S
Esercitazione di Sistemi Operativi − 41
Moreno Marzolla
Esercitazione di Sistemi Operativi − 42
Ricordarsi che nel linguaggio C la valutazione degli
operatori logici && e || è non stretta:
if (a && b) x; else y;
/* programma "a" */
if (fork() && fork())
exec("b");
if (a || b) x; else y;
if (a) {
if (b) x;
else y;
} else
y;
if (a)
x;
else {
if (b) x;
else y; }
exec("c");
Moreno Marzolla
tempo
S
Attenzione!!
"
else
Q
Efficienza: Q / ( Q + S ) = quasi 0
Esercizio 7
È dato il seguente frammento di programma, eseguito nel
Sistema Operativo UNIX. Descrivere l’evoluzione del
programma (quali processi vengono creati, quali programmi
eseguono e quale è il contenuto della memoria del sistema):
S
Esercitazione di Sistemi Operativi − 43
Moreno Marzolla
Esercitazione di Sistemi Operativi − 44
Fork() ed Exec()
"
"
esito fork( )
Svolgimento
Processo "a"
int exec(path, arg)
/* programma "a" */
if (fork() && fork())
"
"
"
"
Crea una copia del
processo che esegue la
fork();
Il codice rimane condiviso,
l’area dati viene duplicata
Il processo creato riceve
esito=0
"
"
fork()
Sostituisce il processo
corrente, lanciando il
programma specificato nel
primo parametro
L’area codice e dati
vengono sovrascritte con
quelle del nuovo processo
Il processo padre riceve
esito=pid del figlio
Processo "a"
padre (fork()>0)
Processo "a"
padre (fork()>0)
exec("b")
Esercitazione di Sistemi Operativi − 45
Un programma prog1 deve mandare in esecuzione i programmi
prog2 e prog3 creando per essi due processi. I programmi
prog2 e prog3 devono evolvere indipendentemente, mentre
prog1 deve aspettare che entrambi i processi creati finiscano
prima di continuare con l’esecuzione. prog1 prosegue poi
chiamando la funzione f2 se è terminato prima prog2, o la
funzione f3 se è terminato prima prog3
exec("c");
exec("c")
Processo "a"
figlio (fork()==0)
Processo "c"
exec("c")
Processo "c"
Moreno Marzolla
Esercizio 8
Scrivere un frammento di programma che utilizzi le funzioni
fork, exec e wait di Unix per realizzare la seguente situazione:
Processo "a"
figlio (fork()==0)
fork()
Processo "b"
Moreno Marzolla
exec("b");
else
Esercitazione di Sistemi Operativi − 46
Svolgimento
idprog2 = fork();
/* Duplica il processo
*/
if (idprog2 == 0)
/* è il figlio?
*/
/* Sì, esegui prog2
*/
/* Come sopra per prog3
*/
execl("prog2", ...);
idprog3 = fork();
if ( idprog3 == 0 )
execl("prog3", ...);
fine1 = wait( &stato );
/* Attende la terminazione */
fine2 = wait( &stato );
/* dei due processi
if ( fine1 == idprog2 )
/* E’ terminato prima prog2? */
*/
f2( );
/* Sì, esegue f2( )
*/
f3( );
/* No, esegue f3( )
*/
else
Moreno Marzolla
Esercitazione di Sistemi Operativi − 47
Moreno Marzolla
Esercitazione di Sistemi Operativi − 48
Esercizio 9
Svolgimento
"
In un sistema time−sharing con priorità sono presenti quattro
processi P1−P4, nel seguente stato: P1, P3 pronti; P2 in esecuzione;
P4 in attesa su operazione di I/O
I processi P1, P2 e P4 hanno priorità uguale, e più alta del processo
P3. Descrivere come cambia lo stato del sistema se, a partire da
questa situazione, si verificano nell’ordine gli eventi seguenti:
a. quanto di tempo
b. completamento dell’operazione di I/O per P4
c. quanto di tempo
d. il processo in esecuzione chiede una operazione di I/O
e. il processo in esecuzione termina.
Moreno Marzolla
Esercitazione di Sistemi Operativi − 49
"
"
a.
b.
c.
P1 ha un CPU burst di 900msec, dopodiché termina;
P2 ha un CPU burst di 150msec, poi si blocca in attesa di un evento A,
che viene completato dopo 400msec, infine ha un ultimo CPU burst di
300msec prima di terminare.
P3 ha un CPU burst di 100msec, poi si mette in attesa di un evento B,
che viene completato dopo 450msec, infine ha un ultimo CPU burst di
100msec prima di terminare.
"
Running=P4,
Ready=P1, P3,
Blocked=P2
e. Il proc. in esec. termina
"
Running=P1,
Ready=P2, P4, P3
Moreno Marzolla
Running=P2,
Ready=P4, P1, P3
d. Proc. in esec. chiede I/O
"
Running=P1,
Ready=P2, P3,
Blocked=P4
Running=P1,
Ready=P3,
Blocked=P2
Esercitazione di Sistemi Operativi − 50
Esercizio 10
In un sistema time−sharing arrivano tre processi P1−P3, che vengono
inizialmente posti in stato di pronto (P1 occupa la testa della coda, poi
vengono P2 e P3). I processi hanno priorità uguale, e vengono schedulati
con algoritmo Round Robin con quanto di tempo 200 millisecondi.
Il comportamento dei processi è il seguente:
"
b. Complet. I/O per P4
"
c. Quanto di tempo
"
Running=P2,
Ready=P1, P3,
Blocked=P4
a. Quanto di tempo
"
"
"
Situazione iniziale :
Svolgimento
P1
200
P2
200
150
P3
400
100
200
150
200
100
200
200
100
450
200
100
100
200
200
200
100
100
100
T (mSec)
Descrivere l’evoluzione dei processi.
Moreno Marzolla
Esercitazione di Sistemi Operativi − 51
Moreno Marzolla
Esercitazione di Sistemi Operativi − 52
Esercizio 11
Soluzione (1)
"
0 < X < 20
"
L’ordine sarà P5−P1−P2−P3−P4
"
I tempi di completamento saranno:
Cinque processi (da P1 a P5) hanno tempo di esecuzione
rispettivamente 20, 40, 50, 70 e X msec. Supponendo che
vengano schedulati con politica Shortest Process Next, quale
sarà il loro tempo medio di completamento? (La risposta
dipenderà dal valore di X).
"
Moreno Marzolla
Esercitazione di Sistemi Operativi − 53
"
P5: X
"
P1: X+20
"
P2: X+20+40
"
P3: X+20+40+50
"
P4: X+20+40+50+70
Media: (5X + 80 + 120 + 100 + 70)/5 = X+74
Moreno Marzolla
Soluzione (2)
"
"
Soluzione (3)
"
20 < X < 40
Esercitazione di Sistemi Operativi − 54
40 < X < 50
"
L’ordine sarà P1−P5−P2−P3−P4
"
L’ordine sarà P1−P2−P5−P3−P4
"
I tempi di completamento saranno:
"
I tempi di completamento saranno:
"
P1: 20
"
P1: 20
"
P5: 20+X
"
P5: 20+40
"
P2: 20+X+40
"
P2: 20+40+X
"
P3: 20+X+40+50
"
P3: 20+40+X+50
"
P4: 20+X+40+50+70
"
P4: 20+40+X+50+70
Media: (100 + 4X + 120 + 100 + 70)/5 = 0,8 X+78
Moreno Marzolla
Esercitazione di Sistemi Operativi − 55
"
Media: (100 + 160 + 3X + 100 + 70)/5 = 0,6 X+86
Moreno Marzolla
Esercitazione di Sistemi Operativi − 56
Soluzione (4)
"
"
"
50 < X < 70
X > 70
"
L’ordine sarà P1−P2−P3−P5−P4
"
L’ordine sarà P1−P2−P3−P4−P5
"
I tempi di completamento saranno:
"
I tempi di completamento saranno:
"
P1: 20
"
P1: 20
"
P5: 20+40
"
P5: 20+40
"
P2: 20+40+50
"
P2: 20+40+50
"
P3: 20+40+50+X
"
P3: 20+40+50+70
"
P4: 20+40+50+X+70
"
P4: 20+40+50+70+X
Media: (100 + 160 + 150 + 2X + 70)/5 = 0,4 X+96
Moreno Marzolla
Esercitazione di Sistemi Operativi − 57
Riepilogo
"
Soluzione (5)
Grafico di f(x), tempo di completamento in funzione di X
Moreno Marzolla
Esercitazione di Sistemi Operativi − 59
"
Media: (100 + 160 + 150 + 140 + X)/5 = 0,2 X+110
Moreno Marzolla
Esercitazione di Sistemi Operativi − 58