Esercitazione di Sistemi Operativi
Transcript
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