Your SlideShare is downloading. ×
Sistema elaboratore in multiprogrammazione
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Sistema elaboratore in multiprogrammazione

730
views

Published on

In un sistema elaboratore in multiprogrammazione ogni programma è inizialmente caricato nel sistema da un lettore di schede, riceve poi una o più iterazioni di CPU e operazioni su nastro o disco e …

In un sistema elaboratore in multiprogrammazione ogni programma è inizialmente caricato nel sistema da un lettore di schede, riceve poi una o più iterazioni di CPU e operazioni su nastro o disco e alla fine esce dal sistema stampando i risultati. Ogni lavoro riceve un numero di iterazioni distribuito geometricamente con media 4 iterazioni prima di uscire dal sistema attraverso la stampante. Terminato un servizio di CPU, se non esce ha 0,875 probabilità di richiedere un servizio disco e 0,125 di richiedere nastro. Il servizio CPU è esponenziale di media 0,8 s; quello di disco uniforme tra 0,5 e 2,5 s, e quello di nastro ancora uniforme tra 2 e 16 s. La coda Q1 è a due livelli A e B con prelazione e priorità a favore di A. All'interno di ciascun livello il servizio è FIFO. Le code Q2 e Q3 siano invece servite SPTF. Il 20% dei lavori in arrivo dall'esterno siano diretti alla categoria A e i rimanenti a B. Nel corso delle iterazioni i lavori conservano la propria classificazione. Il sistema può ospitare soltanto un numero limitato di programmi (Q1 + Q2 + Q3 <= 20). Nell'ipotesi che il sistema funzioni al massimo della capacità (20) determinare media e varianza del numero di lavori espletati per unità di tempo, al 90% del livello di confidenza.

Published in: Technology

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
730
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
1
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Università degli Studi di Perugia LAUREA SPECIALISTICA IN INFORMATICA Anno Accademico 2007/2008 Simulazione Progetto: Sistema elaboratore in multiprogrammazione Studenti: Manfucci Andrea Ciambelli Davide 1
  • 2. Introduzione Il problema In un sistema elaboratore in multiprogrammazione ogni programma è inizialmente caricato nel sistema da un lettore di schede, riceve poi una o più iterazioni di CPU e operazioni su nastro o disco e alla fine esce dal sistema stampando i risultati. Ogni lavoro riceve un numero di iterazioni distribuito geometricamente con media 4 iterazioni prima di uscire dal sistema attraverso la stampante. Terminato un servizio di CPU, se non esce ha 0,875 probabilità di richiedere un servizio disco e 0,125 di richiedere nastro. Il servizio CPU è esponenziale di media 0,8 s; quello di disco uniforme tra 0,5 e 2,5 s, e quello di nastro ancora uniforme tra 2 e 16 s. La coda Q 1 è a due livelli A e B con prelazione e priorità a favore di A. All'interno di ciascun livello il servizio è FIFO. Le code Q2 e Q3 siano invece servite SPTF. Il 20% dei lavori in arrivo dall'esterno siano diretti alla categoria A e i rimanenti a B. Nel corso delle iterazioni i lavori conservano la propria classificazione. Il sistema può ospitare soltanto un numero limitato di programmi (Q1 + Q2 + Q3 <= 20). Nell'ipotesi che il sistema funzioni al massimo della capacità (20) determinare media e varianza del numero di lavori espletati per unità di tempo, al 90% del livello di confidenza. Analisi del modello Il sistema elaboratore in multiprogrammazione è un sistema chiuso formato da 3 nodi principali: una CPU che accetta programmi di tipo A e B ed altri due nodi DISCO e NASTRO che attendono i programmi processati dalla CPU stessa. Come detto precedentemente i programmi ricevono un numero di iterazioni distribuito geometricamente con media 4 prima di uscire dal sistema attraverso la stampante. Il 12,5% dei programmi che esce dalla CPU richiede un servizio NASTRO mentre il restante 87,5% richiede un servizio DISCO. Una volta terminate le operazioni in DISCO e NASTRO i programmi ritornano in CPU. Un programma esce quando il numero di iterazioni corrisponde a zero. Per mantenere costante il numero di programmi nel sistema (20) si genera un nuovo programma ogni volta che uno esce. Avremo quindi un andamento come quello rappresentato in figura: Le code del NASTRO e del DISCO sono disciplinate con politica SPTF (Shortest Processing Time First) dove ha priorità massima il job che richiede minor tempo di servizio. La coda della CPU invece è disciplinata con politica FIFO. Il lettore di schede inizialmente carica nel sistema un numero di programmi pari a 20 che viene mantenuto costante per tutto il tempo della simulazione. In queste condizioni, assumendo per ipotesi che il sistema funzioni al massimo della capacità, è 2
  • 3. nostro compito determinare media e varianza del numero di lavori completati per unità di tempo, al 90% del livello di confidenza. Studio teorico Per rendere più chiara l’analisi del sistema, è necessario spiegare alcuni aspetti essenziali del modello e l'uso di determinate variabili, comprese quelle caratterizzanti le code. Il Tempo medio di Interarrivo (Ta) indica l’intervallo medio di tempo che intercorre tra l’arrivo di un programma alla CPU e il successivo mentre il Tempo medio di Servizio (Ts) mediamente indica quanto tempo spende un programma nel sistema. Considerando che il numero di programmi nella rete è fisso e non sono ammessi arrivi da e partenze per l'esterno, possiamo affermare che questo è un sistema a rete di code chiuso. Reti di questo tipo sono dette reti di Gordon-Newell. Questo modello è analogo al modello di Jackson se non per l'ipotesi che λi = 0, ∀ i ; non si verificano arrivi dall'esterno, tutti gli arrivi provengono da nodi della rete. Ciò significa che il numero di clienti nel sistema è costante e che quando un cliente completa il suo ciclo complessivo di servizi, viene sostituito da un nuovo cliente che inizia il ciclo di servizio. Tale modello è stato introdotto per rappresentare la competizione dei programmi per il processore e per le periferiche di I/O in un sistema di calcolo multiprogrammato. I programmi sono rappresentati dagli utenti e K è il livello di multiprogrammazione. L'esecuzione di un programma sul processore è rappresentata dal servizio al nodo uno, mentre l'attività sulle periferiche è modellata dal servizio negli altri nodi. In particolare si assume che l'esecuzione del programma sia costituita da una successione di segmenti di esecuzioni sul processore e sulle periferiche. Assumendo che il livello di multiprogrammazione sia costante e che vi siano sempre nuovi programmi da elaborare, la terminazione di un programma non cambia il modello se si ipotizza che immediatamente un nuovo programma inizi il suo ciclo di elaborazione. Sia K il numero totale di utenti presenti nella rete. Il vincolo di rete chiusa porta ad una limitazione dello spazio degli stati, che è definito da S={k =k 1, k 2, ... , k N ∣k 1k 2...k N =K } La cardinalità dello spazio degli stati |S| è dunque finita e può essere valutata con un semplice ragionamento di matematica combinatoria. Essa coincide con il numero di possibili suddivisioni dei K clienti in N gruppi, che rappresentano i nodi. Quindi, se si immagina di allineare i clienti lungo una retta, la suddivisione equivale ad inserire N-1 separatori tra i K utenti. Si ottiene così un totale di K+N-1 oggetti, di cui K sono clienti e N-1 separatori. Quindi, il numero delle possibili disposizioni di clienti e separatori è pari al numero di combinazioni di N-1 oggetti su un totale di K+N-1, e quindi si ha  S= K N −1 N −1  Anche nel caso di reti chiuse si definisce la generica probabilità di instradamento nella rete rij come la probabilità che un cliente che termina il servizio nel nodo i entri nel nodo j. Venendo meno il contributo dall’esterno, per ogni nodo j, l'equazione di traffico diventa N λ j=∑ r ij λi , j=1, 2, ... , N i=1 Supponendo di conoscere le probabilità di instradamento, il sistema è un sistema omogeneo di N equazioni in N incognite, per cui esso ammette infinite soluzioni. È quindi possibile calcolare solo i 3
  • 4. valori relativi delle frequenze di arrivo, cioè ad esempio λ j=b j λ1 , j=1, 2, ... , N per cui, dividendo per λ1, le equazioni di traffico diventano N N V j =∑ r ij b i=r 1j∑ r ij bi , j=1, 2,... , N i=1 i =2 che si riduce ad un sistema non omogeneo di N-1 equazioni indipendenti in N-1 incognite e che, quindi, ha soluzione unica. Come già per le reti aperte, anche ora il problema è quello di calcolare le probabilità (stazionarie) di ciascuno stato n + (n1,n2,...,nN). Prima di fare ciò, è necessario definire, per ogni stazione i, cosa intendiamo adesso per valore atteso del numero di volte che ciascun programma passerà per la stazione i (che chiameremo visit count). Infatti, essendo la rete chiusa, occorrerà specificare convenzionalmente l'ingresso e l'uscita di un programma dal sistema. Denotiamo quindi Vi come il visit count del nodo i con Vi > 0. Da ciò possiamo enunciare che N ∑ Vi=1 i=1 Se vi(t) è il numero di volte che un programma passa nel nodo i nell'intervallo [0,t] allora vi V i lim = t ∞ vj V j Un altro importante parametro associato a ciascuna stazione in una rete di code chiusa è la quantità di tempo che, mediamente, un programma trascorre in servizio in un centro i. Tale quantità viene indicata con ai ed è ovviamente legata a μj e al numero di volte che il centro i viene visitato. Una volta noti i valori delle Vj, è possibile calcolare il traffico offerto a ciascun nodo a meno di una costante moltiplicativa V a j= j μj Adesso siamo in grado di calcolare la probabilità che uno dei nodi sia occupato, con K che corrisponde al numero dei programmi nel sistema (nel nostro caso 20) e con μj = μ, con i = 1,2,3. Se per esempio vogliamo calcolare la probabilità che il nodo 3 sia occupato denotiamo V1 V a= e b= 2 μ μ mentre 2 2 G=3a 2abb sapendo poi che P nodo 3 occupato=1−P  nodo 3 libero 4
  • 5. abbiamo 2 2 a abb P nodo 3 libero= G da cui 2 2a ab P nodo 3 occupato= 2 2 3a 2abb La soluzione del problema di analisi di una rete di code chiusa, nelle ipotesi viste, richiede dunque il calcolo della costante di normalizzazione G(N). Questa costante è data da N G= ∑ ∏ ain i n1...n N= K i=1 Analisi matematica Analizziamo ora alcuni parametri che poi verranno confrontati con i risultati delle simulazioni. Stima del tempo di servizio ts Da testo sappiamo che ci sono 20 programmi che girano costantemente nel sistema finché non esauriscono il loro numero di iterazioni. Un programma, dopo essere stato processato dalla CPU, ha il 12,5% di probabilità di richiedere un servizio NASTRO e il restante 87,5% di richiedere un servizio DISCO per poi tornare nuovamente alla CPU. Sapendo ciò possiamo stimare che su 20 programmi, 2,5 richiederanno un servizio NASTRO mentre 17,5 richiederanno un servizio DISCO. Inoltre è importante ricordare che il numero medio di iterazioni che riceve un programma è pari a 4. Quindi possiamo calcolare il tempo medio di servizio come: ● 20 ∙ (0,8 ∙ 4) + 2,5 ∙ (9 ∙ 3) = 131,5: tempo medio di permanenza di un programma passando per NASTRO; ● 20 ∙ (0,8 ∙ 4) + 17,5 ∙ (1,5 ∙ 3) = 142,75: tempo medio di permanenza di un programma passando per DISCO. Allora 131,5142,75 t s= =13,71 20 Stima del tempo di interarrivo Il nostro sistema è rappresentato da una rete di Gordon-Newell perciò il tempo di interarrivo è stato calcolato singolarmente per ciascun nodo. Sapendo che N corrisponde a 20 programmi e K corrisponde a 3 nodi abbiamo calcolato la cardinalità dell'insieme degli stati S che rappresenta il modo in cui i programmi si distribuiscono nel sistema   [ S ]= 202 =231 2 Poi siamo passati alla creazione della matrice di diramazione r 5
  • 6.   7 1 0 r ij = 8 8 1 0 0 1 0 0 dove all'elemento rij corrisponde la probabilità che un programma ha nel raggiungere il nodo j dal nodo i. Dalla matrice r abbiamo risolto il sistema che ne deriva { λ1= λ2 λ3 7 λ 2 = λ1 8 1 λ 3 = λ1 8 La soluzione di questo sistema è indeterminata in quanto λ1 = λ1, infatti ammette infinite soluzioni. Vista l'impossibilità di procedere in questo senso è stato necessario calcolare i visit count. Il visit count della CPU è V 1=1 V 2 1V 3 Il visit count del DISCO è V 2 =0,875V 10 V 3 Il visit count del NASTRO è V 3=0,125V 1 0 V 2 dove i coefficienti rappresentano le probabilità viste nella tabella di diramazione. Risolvendo il sistema che deriva da queste equazioni abbiamo trovato i seguenti valori V 1 =1 V 2 =0,875 V 3 =0,125 A questo punto abbiamo calcolato il throughput (traffico offerto) per ciascun nodo: 6
  • 7. V1 1 a1= = =1,25 μ1 0,8 V 2 0,875 a 2= = =0,583 μ2 1,5 V 0,125 a 3= 3 = =0,014 μ3 9 Questi sono i valori relativi al throughput di ciascun nodo (ad esempio per il nodo CPU il traffico offerto ad ogni istante di tempo è pari ad 1,25 programmi). Dopodiché abbiamo calcolato le probabilità che, ad un certo istante di tempo, un nodo sia libero oppure occupato. Qui a e b rappresentano i Vj/μj. Visto che a e b sono parametri associati al nodo di cui si vuol calcolare la probabilità, per semplicità prenderemo in esame solo il nodo CPU (per gli altri nodi il ragionamento è lo stesso). 0,875 a= =0,583 1,5 0,125 b= =0,014 9 Da questi valori ci calcoliamo il coefficiente di normalizzazione G G=1.0170.0160,00019=1.037 Ora abbiamo tutti i valori che ci permettono di calcolare la probabilità 0.3390.0080.00019 P CPU libera= =0.336 1.037 La probabilità che la CPU sia occupata è 1−P CPU libera =1−0.336=0.663 Progettazione Vediamo in questa sezione i passi che abbiamo fatto per progettare il simulatore. Meccanismo di avanzamento del tempo Una delle più importanti considerazioni nella formulazione del modello è il metodo usato per l'avanzamento del tempo. Prima di tutto va fatta una distinzione fra tre concetti di tempo: ● Tempo reale: è quello proprio del sistema reale da simulare (in genere una variabile continua); ● Tempo simulato: è la rappresentazione del tempo reale nel modello. Il funzionamento del modello è rappresentato da una sequenza di cambiamenti di stato (eventi) discreti che si assume avvengano istantaneamente, senza consumo di tempo. Il tempo simulato è una variabile che assume valori discreti a istanti detti istanti critici. Questi istanti possono 7
  • 8. coincidere oppure no con l'occorrenza di eventi. Nel primo caso si parla di avanzamento per eventi (next-event, o event-oriented), mentre nel secondo si parla di avanzamento per intervalli (fixed-time-step, o interval oriented). L’avanzamento del tempo simulato è registrato da una variabile interna il cui valore istantaneo è detto tempo di clock; ● Tempo di esecuzione: è il tempo consumato dall'elaboratore per l'esperimento di simulazione. Dipende dal numero e dalla complessità dei cambiamenti di stato che hanno luogo nel sistema e non dalla scala degli intervalli di tempo simulati. La scelta relativa all'avanzamento del tempo simulato è stata di tipo event-oriented e adottando questa “politica” il tempo di clock viene fatto avanzare ogni volta fino al tempo di occorrenza del prossimo evento in calendario. In tal modo si scavalcano tutti i periodi di tempo durante i quali non hanno luogo cambiamenti nel sistema. Schema della simulazione Effettuate tutte le scelte per la simulazione, si è stabilito lo schema generale, da cui poi è scaturito l'algoritmo. Come possiamo notare la simulazione è suddivisa nei seguenti blocchi Inizializzazione In questa parte vengono: ● caricati i 20 programmi; ● costruite tutte le strutture utilizzate dal simulatore; ● creati gli oggetti delle classi che permetteranno la generazione dei numeri random; ● creati gli eventi iniziali che consentiranno lo START del sistema e l'evento FINE che permetterà la terminazione della simulazione; ● stabiliti i numeri random. 8
  • 9. Clock e switch event È in questo blocco che viene schedulato il tempo per eventi ovvero il current_time=ev.tempo dell'evento ev estratto, che poi verrà gestito in base al tipo dello stesso. Terminazione Questo avverrà nel momento in cui verrà estratto l'evento FINE generato in fase di inizializzazione. Da questo momento in poi, sarà possibile calcolare le statistiche della simulazione. La gestione degli eventi Vediamo ora come si è pensato di muoversi al verificarsi di un certo evento. PROG_A Notiamo in figura cosa avviene quando viene estratto un evento di tipo PROG_A. Possiamo vedere che, una volta riconosciuto l'evento e aggiornato il current_time, viene verificato il valore del flag cpu_libera; nel caso in cui sia false l'elemento viene inserito nella coda Q1 al livello A altrimenti se è true viene generato un nuovo evento uscita_cpu che rappresenta il completamento del programma. 9
  • 10. PROG_B Notiamo figura cosa avviene quando viene estratto un evento di tipo PROG_B. Possiamo vedere che, una volta riconosciuto l'evento e aggiornato il current_time, viene verificato il valore del flag cpu_libera; nel caso in cui sia false l'elemento viene inserito nella coda Q1 al livello B altrimenti se è true viene generato un nuovo evento uscita_cpu che rappresenta il completamento del programma. 10
  • 11. USCITA_CPU Notiamo in figura cosa avviene quando viene estratto un evento di tipo USCITA_CPU. Possiamo vedere che, una volta riconosciuto l'evento e aggiornato il current_time, viene settato il valore del flag cpu_libera a true in quanto a questo evento corrisponde il completamento del lavoro della CPU e viene preso in esame il numero di iterazioni del programma. Se ev.n_iter=0 il programma esce dal sistema attraverso la stampante e ne viene creato immediatamente uno nuovo; se invece ev.n_iter>0 viene decrementato di un'unità questo numero e viene creato un nuovo evento (uscita_d o uscita_n) a seconda della probabilità. Nel caso in cui il nodo di destinazione fosse occupato, il programma viene messo nella rispettiva coda (Q 2 o Q3). Prima che la routine termini il programma esamina le code della CPU (ricordando che A ha priorità su B). 11
  • 12. USCITA_D Notiamo in figura cosa avviene quando viene estratto un evento di tipo USCITA_D. Possiamo vedere che, una volta riconosciuto l'evento e aggiornato il current_time, viene settato il valore del flag disco_libera a true in quanto a questo evento corrisponde il completamento del lavoro del DISCO e viene verificato il valore del flag cpu_libera; se è true viene generato un nuovo evento uscita_cpu mentre se è false il programma viene inserito nella coda Q1 al livello A o B a seconda della sua priorità. Prima che la routine termini il nodo esamina la propria coda Q2. 12
  • 13. USCITA_N Notiamo in figura cosa avviene quando viene estratto un evento di tipo USCITA_N. Possiamo vedere che, una volta riconosciuto l'evento e aggiornato il current_time, viene settato il valore del flag nastro_libera a true in quanto a questo evento corrisponde il completamento del lavoro del NASTRO e viene verificato il valore del flag cpu_libera; se è true viene generato un nuovo evento uscita_cpu mentre se è false il programma viene inserito nella coda Q1 al livello A o B a seconda della sua priorità. Prima che la routine termini il nodo esamina la propria coda Q3. FINE All'estrazione dell'evento FINE la simulazione volge al termine e da questo momento in poi sarà possibile iniziare ad effettuare i calcoli per le statistiche in base ai dati via via accumulati. Il metodo delle prove ripetute Il nostro scopo sarà quello di andare a determinare, assumendo N = 20 programmi, i valori di media e varianza dei lavori espletati per unità di tempo, al 90% del livello di confidenza. Innanzi tutto partiamo col dire che l'accumulo delle statistiche parte dopo 1000 secondi in quanto in questo lasso di tempo il sistema si deve ancora stabilizzare. È importante sottolineare che il tempo di stabilizzazione del simulatore può variare col seme per le imperfette proprietà aleatorie dei generatori pseudocasuali. Successivamente abbiamo diviso l'intervallo di tempo totale in 200 parti da 40 secondi ciascuna in modo da ottenere un numero significativo di programmi completati per unità di tempo. Ora andiamo a vedere come sarà lo schema che ci permetterà di effettuare più 13
  • 14. esperimenti e da questi stimare i valori richiesti dal problema. Lo schema in questione è raffigurato in figura Sia xij la i-esima osservazione fatta nel j-esimo esperimento, e sia nj il numero di osservazioni fatte nel j-esimo esperimento. Per ciascun esperimento si sceglierà una durata atta a garantire un nj sufficientemente grande ma casuale e finito. Quindi avremo la serie di p campioni ciascuno formato da una serie di nj osservazioni autocorrelate. Essi sono 1  x 11 x 21 ⋯ xn 1 1 2 x 12 x 22 ⋯ xn 2 2 ⋮ j  x 1j x 2j  xn j j ⋮ p  x 1p x 2p  xn p p Per j = 1, 2, . . . , p, introduciamo le variabili Nj y j=∑ x ij i =1 Nj 2 z j =∑ x ij i=1 14
  • 15. Se il sistema ha raggiunto la stazionarietà ed i p esperimenti sono condotti con numeri random indipendenti, ciascuna delle tre serie y1 y2  y j y p z1 z2  z j z p n1 n2  n j n p può considerarsi formata da osservazioni di tipo i.i.d. (indipendenti e identicamente distribuite). Per quanto riguarda il livello di confidenza, esso ci servirà a determinare gli intervalli nei quali dovrà cadere il 90% dei nostri esperimenti. Vediamo ora come si fa a trovare il parametro uα/2 che ci permetterà di determinare gli intervalli interessati: α α 1−α=0,90 α=0,10 =0,05 1− =0,95 2 2 Dalle tavole della distribuzione cumulativa si ricava per F( uα/2 ) = 0.95 il valore uα/2= 1.645, come possiamo vedere dalla tabella a pagina 188 del libro A questo punto andiamo a calcolare il seguente valore p = p ∙∑ x j −1 x j =1 che consiste nella media verticale di tutti i nostri esperimenti; andiamo poi a calcolare la varianza n 1 s 2= ∙ ∑  x i − 2 x n−1 i =1 A questo punto siamo pronti a calcolare gli intervalli di confidenza inferiore= − x   s n uα/ 2 superiore=   x   s n uα / 2 dove s è la radice della varianza, n è il numero di prove effettuate e uα/2 è il valore proveniente dalla tabella vista in precedenza. Il 90% del livello di confidenza significa che sulle 100 prove da noi effettuate, 90 di queste hanno il valore medio interno a tale intervallo. Di seguito vengono mostrati due grafici relativi all'andamento nel tempo dei programmi completati. 15
  • 16. In questo grafico viene mostrata l'area in cui il simulatore non è ancora stabile e perciò non viene considerata nelle statistiche. In questo secondo grafico invece viene mostrato l'andamento dell'esperimento. Le tre linee mostrano rispettivamente l'intervallo inferiore (linea rossa), la media (linea nera) e l'intervallo superiore (linea verde). Come si può vedere, su 100 prove, all'incirca 90 valori cadono nell'intervallo mentre i restanti cadono all'esterno. Convalida Dopo la simulazione, e la successiva rilevazione dei dati, bisogna controllare se questi sono coerenti oppure no con il modello adottato. Bisogna far vedere infatti che, dopo un certo numero di esperimenti, i tempi che il simulatore mostra in output, siano effettivamente veritieri con i tempi calcolati matematicamente in precedenza. Le statistiche Confrontiamo ora i risultati calcolati su carta con quelli calcolati dal simulatore. Per fare ciò ci basta prendere in considerazione i risultati di un semplice esperimento con un tempo simulato elevato (8000 nel caso specifico). Di seguito viene mostrato un output del simulatore dove vengono 16
  • 17. confrontati i valori teorici con quelli del simulatore. Possiamo quindi notare che tutti i tempi, le probabilità e le percentuali calcolate matematicamente hanno un riscontro reale con il simulatore. I dati non sono effettivamente precisi ma hanno un margine di errore molto basso. Peraltro il modello risulta accettato. 17