MODELLISTICA DI IMPIANTI E SISTEMI 2

MODELLISTICA DI IMPIANTI E
SISTEMI 2
VinX e tutti i ragazzi che hanno condiviso i loro appunti!!!
Indice
1 Modello a coda
1.1 Modello a coda di un centro singolo . . . .
1.1.1 Legge degli arrivi . . . . . . . . . . .
1.2 Legge dei servizi . . . . . . . . . . . . . . .
1.2.1 Proprietà memoryless . . . . . . . .
1.3 Input ed Output del modello . . . . . . . .
1.3.1 Fattore di utilizzazione del centro: ρ
1.4 Serventi Multipli . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
3
4
7
8
9
2 Leggi del modello a coda
2.1 Teorema di Little . . . . . . . . . . . . . . . . . . . . . . .
2.2 Leggi fondamentali del centro singolo . . . . . . . . . . . .
2.2.1 Notazione di Kendall . . . . . . . . . . . . . . . . .
2.2.2 Caso M/G/1 . . . . . . . . . . . . . . . . . . . . .
2.2.3 Caso M/D/1 . . . . . . . . . . . . . . . . . . . . .
2.2.4 Caso M/M/1 . . . . . . . . . . . . . . . . . . . . .
2.2.5 Caso M/Ek /1 . . . . . . . . . . . . . . . . . . . . .
2.2.6 Caso M/H2 /1 . . . . . . . . . . . . . . . . . . . . .
2.2.7 Andamento delle variabili di uscita . . . . . . . . .
2.3 Sensibilità ai fattori ed alle discipline . . . . . . . . . . . .
2.3.1 Sensibilità ai fattori . . . . . . . . . . . . . . . . .
2.3.2 Sensibilità alle discipline . . . . . . . . . . . . . . .
2.4 Tempo di attesa e tempo rimanente di servizio . . . . . .
2.5 Utilizzazione . . . . . . . . . . . . . . . . . . . . . . . . .
2.6 Processor Sharing (PS) . . . . . . . . . . . . . . . . . . . .
2.7 Hazard Rate Function . . . . . . . . . . . . . . . . . . . .
2.8 LIFO con prelazione (non job-size) . . . . . . . . . . . . .
2.9 Heavy Tail . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.9.1 Bilanciamento del carico in una rete di workstation
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
10
10
11
11
11
11
12
12
12
13
14
14
15
15
16
18
18
19
21
21
3 Discipline dei modelli a coda
3.1 Centro singolo con disciplina prioritaria . . . . . . . . . . . . . .
3.2 Discipline senza prelazione . . . . . . . . . . . . . . . . . . . . . .
3.2.1 Priorità astratta senza prelazione (PASP) . . . . . . . . .
3.2.2 Priorità basate su tempo senza prelazione (PTSP) . . . .
3.2.3 Confronto tra PTSP e PASP . . . . . . . . . . . . . . . .
3.2.4 Shortest Processing Time First (SPTF) . . . . . . . . . .
3.3 Discipline con prelazione . . . . . . . . . . . . . . . . . . . . . . .
3.3.1 Disciplina a priorità astratta con prelazione (PACP) . . .
3.3.2 Disciplina a priorità non astratta con prelazione (PTCP)
3.3.3 Shortest Remaining Processing Time First (SRPTF) . . .
3.3.4 Confronti tra discipline . . . . . . . . . . . . . . . . . . .
3.3.5 Confronto tra PTSP e PASP . . . . . . . . . . . . . . . .
3.3.6 Confronto tra PACP e PASP . . . . . . . . . . . . . . . .
3.4 Centro a processori multipli . . . . . . . . . . . . . . . . . . . . .
3.4.1 Caso M/M/m astratto . . . . . . . . . . . . . . . . . . . .
3.4.2 Numero di serventi occupati . . . . . . . . . . . . . . . . .
3.5 Effetto della distribuzione di capacità e dei fattori di scala . . . .
3.5.1 Problema della distribuzione di capacità . . . . . . . . . .
3.5.2 Problema del fattore di scala . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
23
23
23
23
26
27
29
30
30
31
32
32
33
34
35
35
36
38
38
40
I
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4 Modelli a reti di code
4.1 Soluzione Markoviana . . . . . . . . . . . .
4.1.1 Calcolo degli indici . . . . . . . . . .
4.2 Capacità limitata della coda . . . . . . . . .
4.2.1 Modelli di blocco . . . . . . . . . . .
4.2.2 Analisi dei modelli (servente singolo)
4.3 Definizione degli indici . . . . . . . . . . . .
4.4 Modelli di reti a code separabili . . . . . . .
4.4.1 Teorema di Burke . . . . . . . . . .
4.4.2 Teorema di Jackson . . . . . . . . .
4.4.3 Teorema di Gordon & Newell . . . .
4.4.4 Distribuzione marginale . . . . . . .
4.4.5 Utilizzazione . . . . . . . . . . . . .
4.4.6 Throughput locali . . . . . . . . . .
4.4.7 Tempi di residenza . . . . . . . . . .
4.4.8 Teorema BCMP . . . . . . . . . . .
4.5 Decomposizione/Aggregazione . . . . . . . .
4.6 Quality of Service e Performance . . . . . .
A Formulario
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
42
45
46
48
48
49
53
55
56
56
57
58
58
59
59
59
62
66
71
II
1
Modello a coda
Per descrivere la qualità di un sistema si usano tre caratteristiche fondamentali:
1. Efficienza;
2. Affidabilità;
3. Sicurezza.
L’approccio rigoroso o scientifico è usato per determinare la qualità di un impianto. Esso individua gli
strumenti e i metodi per la valutazione di indici di qualità di sistemi, impianti, reti, ecc. . . Ognuno ha
indici specifici ma i modelli sono simili tra loro.
La conoscenza del constesto applicativo e del sistema porta:
1. alla definizione e produzione di un modello;
2. alla sua soluzione di tale modello.
Un’altro aspetto nuovo che si sta affermando è l’uso dei modelli nella fase di gestione (online) per rilevare
situazioni particolari ed operare un tuning finalizzato.
1.1
Modello a coda di un centro singolo
Le grandezze che ci servono per descrivere questo modello sono:
• Legge degli arrivi: la legge che governa il flusso di traffico in arrivo.
• Legge dei servizi : una volta che il job trova il servente libero questo viene servito.
I modelli sono probabilistici e pertanto tali leggi sono di tipo probabilistico.
Sorgente
Rappresenta il numero di job che arrivano in una finestra temporale.
Disciplina o Scheduling È l’ordine secondo il quale i job della coda vengono estratti per ricevere
servizio appena il servente si libera. Questo può essere:
• di natura “astratta” ovvero non dipendente dalla natura della richiesta (LIFO, FIFO, RAND)
oppure
• dipende dalla richiesta dei job (i job che richiedono minori risorse).
1.1.1
Legge degli arrivi
Ci sono due modi per descrivere una sorgente, ovvero il numero degli arrivi che si hanno in una finestra
temporale. Questo numero è rappresentato da una variabile aleatoria che ha una distribuzione di tipo
probabilistico.
1
Distribuzione di Poisson
La probabilità di avere n arrivi in un intervallo di tempo (0, t] è:
n
(tλ) e−tλ
n!
P (n)t =
E [n]t = tλ
σ 2 (n)t =
+∞
X
2
(n − tλ) p (n)t = tλ
n=0
dove λ è chiamato parametro della distribuzione ed n > 0. Si nota inoltre che questa legge possiede la
varianza pari alla media. Se t = 1 allora λ è una frequenza.
Tempo di interarrivo Non indica quanti arrivi ci sono in un certo istante ma quanto vale il tempo di
interarrivo ovvero il tempo che passa tra un arrivo ed un altro. Viene indicato con la variabile aleatoria
ta , che possiede una distribuzione, una media ed una varianza.
Distribuzione esponenziale
C’è una strana relazione tra la legge di Poisson con quella esponenziale. Infatti, se gli arrivi sono descritti
da una legge di Poisson, il tempo di interarrivo segue la legge esponenziale.
La densità di probabilità della legge esponenziale è:
f (t) = λe−tλ
dove:
1. La funzione cumulativa, ovvero F (t′ ) = P (t ≤ t′ ), è:
′
F (t ) =
Z
t′
′
f (t) dt = 1 − e−t λ
0
2. La sua media, ovvero la somma di tutti i valori assumibili dalla variabile per la sua probabilità, è:
E [t] =
Z
+∞
tf (t) dt =
0
1
λ
3. La sua varianza, ovvero il quadrato della variabile meno il suo valor medio pesato per la sua
probabilità, è:
σ 2 (t) =
Z
0
+∞
µ
t−
1
λ
¶2
f (t) dt =
1
= E 2 [ts ]
λ2
In questo caso la varianza è il quadrato della media. La varianza in generale è considerabile come un
indice di qualità. Infatti una varianza molto grande spesso è simbolo di instabilità.
Inoltre nel caso dell’esponenziale si può prendere come riferimento la seguente relazione:
C2 =
σ 2 (t)
=1
E 2 [t]
2
Dimostrazione
esponenziale:
Il tempo di interarrivo ta di legge Poissoniana è rappresentato da una variabile
F (t) = P (ta ≤ t) = 1 − P (ta > t)
in ta non devo avere arrivi, cioè il prossimo arrivo sarà dopo l’istante t, quindi:
0
1 − P (0)t = 1 −
(tλ) e−tλ
= 1 − etλ
0!
dove f (t) = δFδt(t) = λe−tλ .
Quindi notiamo che la funzione cumulativa, usando le formule della legge di Poisson, segue la legge
della distribuzione esponenziale.
La legge degli arrivi può essere modellata in due modi diversi:
1. Dato un numero medio di arrivi in una finestra temporale, all’interno di una finestra si contano gli
arrivi e poi su un intervallo lungo se ne fa la media.
2. Viene misurata la variabile ta e poi viene fatta la media.
Utilizzando una distribuzione degli arrivi Poissoniana, il tempo di interarrivo tra questi è di tipo
esponenziale.
1.2
Legge dei servizi
Domanda di servizio È il numero di operazioni elementari richieste al centro dal job. Ad esempio:
la domanda di servizio media ds = 100 operazioni (per job).
Velocità di servizio È il numero di operazioni elementari nell’unità di tempo fornite dal centro. Ad
esempio: vs = 10 operazioni/secondo. Considera anche l’overhead dovuto agli strati software.
3
Tempo di servizio medio del job È rappresentato dalla variabile ts ed è pari al rapporto tra la
domanda e la velocità di servizio, ovvero:
ts =
ds sec
vs job
Esempio
Qual’è la probabilità che la richiesta di tempo di servizio sia inferiore alla media?
Sia E [ts ] = Ts allora:
¯
F (Ts ) = P (ts ≤ Ts ) = 1 − e−µt ¯t=1/µ = 1 − e−1 = 0.6321
È bene notare che per qualsiasi intervallo che sia funzione della media, la probabilità che la variabile
aleatoria cada nell’intervallo è indipendente da µ.
1.2.1
Proprietà memoryless
Il passato della variabile non ha influenza sul suo futuro.
Nel caso del tempo di interarrivo ta , se gli arrivi sono distribuiti secondo la legge di Poisson, tale
variabile è di tipo esponenziale che gode della proprietà memoryless. Supponiamo che nell’istante 0
abbiamo un arrivo. A partire dall’istante 0, vogliamo sapere qual’è la probabilità che ci sia un arrivo al
tempo t. Ovvero P (ta ≤ t) = 1 − e−tλ . Se invece al tempo 0 abbiamo un arrivo e passa un certo tempo
t0 senza osservare altri arrivi, allora qual’è la probabilità che ci sia un arrivo al tempo t0 + t:
P (ta ≤ t0 + t|ta > t0 ) =
=
P (t0 <ta ≤t0 +t)
(ta ≤t0 )
= P (ta ≤tP0 +t)−P
P (ta >t0 )
(ta >t0 )
−λ(t0 +t)
−t0 λ
−λ(t0 +t)
−t0 λ
1−e
−(1−e
)
= −e e−t0 λ+e
1−(1−e−t0 λ )
=
= 1 − e−tλ
Quindi la probabilità che ci sia un arrivo dopo aver osservato che entro t0 non ce ne sono stati, è
esattamente identica alla probabilità che ci sia un arrivo in un tempo lungo t dall’ultimo. Di conseguenza
la conoscenza della storia della variabile non ha influenzato il futuro, non aggiunge informazioni.
Pensiamo ad una variabile aleatoria X interpretata come tempo di vita:
P (X > s + t|X > s)
dove t è il tempo di vita rimanente. La proprietà memoryless ci dice che la probabilità è uguale a quella
che X > t, ma essa può variare in due modi:
1. decresce al crescere di s.
Le distribuzioni di questo tipo sono dette a failure rate crescente;
2. cresce al crescere di s.
Ad esempio, il tempo di servizio dei job in Unix: tanto più un job ha usato la cpu, tanto più è
probabile che continuerà ad usarla.
Un altro esempio è il tempo di vita dei microchip: si fanno i test per un certo tempo e se lo superano
vengono messi in commercio. Se ci sono guasti, questi si presentano abbastanza subito.
Distribuzione erlangiana (K-Erlang)
C’è un solo servente il cui tempo di servizio è modellato con più stadi. All’interno ci può stare un solo
job per volta. Quindi se il job entra nello stadio 1, allora solo quando esce dallo stadio k può entrare un
altro job.
Tale distribuzione rappresenta solo la modellizzazione di un tempo e non quella di un servente multiplo.
Sia ts il tempo di permanenza del job all’interno del centro, senza avere una coda. In ognuno degli stadi
il job spenderà tks istanti di tempo. I tempi di servizio secondo questo schema vengono detti K-Erlang
dove abbiamo una sequenza di k esponenziali. La densità di ogni singolo stadio i-esimo è:
4
Mentre la densità dell’intera variabile è:

−ktµ
 fi (t) = kµe
ts
E (tsi ) = k
¡ ¢2
 2
σ (tsi ) = tks

k e−ktµ k−1

t
 f (t) = (kµ)
Pk (k−1)!
ts
E (ts ) = i=1 k = ts

Pk ¡ ¢2
 2
t2
σ (ts ) = i=1 tks = ks
Se confrontiamo con un centro singolo lo stesso tempo di servizio, la varianza risulta essere k volte più
piccola. Quindi essendo la varianza un indice di qualità, il centro con distribuzione K-Erlang è migliore,
ovvero i valori della variabile sono meno dispersi rispetto al suo valor medio.
Tipici esempi di distribuzioni erlangiane sono: un job che chiede alla cpu k programmi diversi oppure
un disco che fa una serie di operazioni successive.
Distribuzione Iper-Esponenziale
Con questa legge ci troviamo in una situazione if S1 then else S2 , dove S1 e S2 sono servizi alternativi.
5
Il job esegue il servizio S1 con probabilità p oppure il servizio S2 con probabilità 1 − p. Ogni stadio
è descritto da una funzione esponenziale semplice, quindi la funzione di densità dell’intera variabile è
composta dalla seguente formula:
½
f1 (t) = 2pµe−2ptµ
⇒ f (t) = pf1 (t) + (1 − p) f2 (t)
f2 (t) = 2 (1 − p) µe−2(1−p)tµ
Di conseguenza la media e la varianza di tale distribuzione è pari a:

(t ) = µ1 = ts

 E
( s
2
σ 2 (ts ) = g(p)
µ2 = g (p) ts

1

g (p) = 2p(1−p) − 1
Per p = 0.5, l’Iper-Esponenziale coincide con l’esponenziale. La varianza aumenta sensibilmente quanto
più p tende a 0 oppure ad 1. Se abbiamo p = 1 non bisogna utilizzare tale distribuzione, dato che
partiamo dal presupposto che ci siano due possibilità di scelta. Ha proprietà memoryless.
Ad esempio, supponiamo che p = 0.8 e µ = 2 job/sec allora dato che la media di un’esponenziale è
pari a λ1 allora:
E [ts1 ] =
E [ts2 ] =
1
2pµ = 0.315
1
2(1−p)µ = 1.25
Notiamo che abbiamo un 20% di job che richiedono un tempo che è 400% dell’altro, ovvero abbiamo
un’alta varianza, maggiore della legge esponenziale.
Distribuzione Coxiana
Se si ha una distribuzione generale che non rientra nelle categorie precedenti allora è sempre possibile
trovare una distribuzione di tipo coxiana.
Una distribuzione Coxiana possiede le seguenti proprietà:
• possiede la proprietà memoryless,
• è sempre un servente singolo che si comporta in un certo modo,
6
• ogni stadio è esponenziale,
• è possibile una uscita da ognuno degli stadi,
• un job continua dallo stadio 1 allo stadio 2 con probabilità a1 mentre esce con probabilità b1 .
• ak = 1.
Quindi il tempo speso dal job nel centro sarà:
• t1 con probabilità b1
• t1 + t2 con probabilità a1 · b2
Pk
Qk−1
•
i=1 ti con probabilità bk
i=1 ai
1
µci
Partiamo da una f (t) qualsiasi, ovvero la distribuzione del tempo di servizio. Se questa f (t) ha
trasformata di Laplace razionale esiste sempre una Ck (t) con k grande quanto serve che approssima con
precisione arbitraria (al massimo con un errore nullo) la f (t).
Se invece la trasformata di Laplace non è razionale si può solo approssimare con Ck (t), mentre
nell’altro caso con k grande a piacere si può trovare una Ck (t) identica alla f (t).
E (tsi ) =
1.3
Input ed Output del modello
Consideriamo il caso in cui si vuole bilanciare il carico di una rete di workstation. Ogni workstation
lavora in time sharing. Può essere utile migrare un job da una postazione all’altra in modo da migliorare
i tempi di risposta e lo slowdown. Ma la migrazione può essere costosa perché il job si porta dietro tutto
il suo stato.
Esistono due tecniche di migrazione:
1. non-preemptive (NP): sono rilocati solo i job appena nati (remote execution o initial placement).
È una tecnica che non usa lo stato.
2. preemptive (P): i job si portano dietro il loro stato per ogni migrazione (active process migration).
La prima politica costa molto di meno, ma a volte non basta. Se i job sono caratterizzati esponenzialmente, lo è anche il tempo rimanente dei job e si potrebbe decidere di rilocare solo i processi più
giovani.
Se però i job hanno distribuzioni heavy tailed, si può ipotizzare che i job vecchi hanno tempo rimanente
più lungo e può essere più sensato rilocare i job vecchi, dato che hanno un tempo rimanente probabilmente
ancora lungo.
7
Tra le variabili di input del modello abbiamo:
• Legge degli arrivi: rappresentata dal suo parametro λ.
• Legge dei servizi: rappresentata dal suo parametro µ.
• λ: numero medio di job che arrivano alla sorgente per unità di tempo.
• ts : tempo di servizio.
• m: numero di serventi.
Mentre quelle di output sono tutte le variabili aleatorie di cui bisogna calcolare la media:
• w: numero di job nella coda.
• q: numero di job nel centro, ovvero i job presenti sia in coda che nel servente, quindi al massimo
w + 1.
• tw : tempo che il job passa nella coda.
• tq : tempo che il job passa in tutto il centro, cioè tw + ts .
• nt : numero di job che escono da un centro in un tempo t.
Dato che le variabili che consideriamo sono delle medie quindi bisogna considerare E[w], E[q], . . .
Se t = 1 allora E[n1 ] è il throughput del centro, ovvero il numero di job che esce dal centro per unità
di tempo. Dato che la quantità media di job che entra deve coincidere con quella che esce (in condizione
di equilibrio, ovvero λ < µ) vale la seguente relazione: E[n1 ] = λ. Se invece λ ≥ µ allora non sono in
equilibro e E[n1 ] = µ, infatti non può uscire di più di quella che è la capacità di smaltimento del centro.
In formule:

tq = tw + ts




q
=w+m


 E[q] = E[w] + mρ
 E [tq ] = E [tw ] + E [ts ]

1


 µ = E[ts ]


λ
s]
= λE[t
ρ = mµ
m
1.3.1
Fattore di utilizzazione del centro: ρ
Se tutto funziona correttamente tutto ciò che entra deve anche uscire quindi in condizioni normali non
di sovraccarico quello che ci aspettiamo è vedere uscire quello che entra. Quindi se in media entra λ in
uscita si ottiene: λ se λ < µ oppure µ se λ ≥ µ e la coda cresce all’infinito.
Partiamo dall’assunzione che λ < µ. Il fattore di utilizzazione è definito come: ρ = µλ . Da cui ρ < 1
se λ < µ.
Sia dato un intervallo sufficientemente lungo T (tempo di occupazione totale) e sia I l’intervallo di
tempo libero nel tempo T (tempo libero totale) allora T − I è il tempo di occupazione del centro. Quindi:
T −I
è la percentuale di utilizzazione del centro, pertanto:
T
T −I
T →+∞
T
ρ = lim
dove T coincide con la somma dei tempi di interarrivo quindi l’operazione di limite diventa il calcolo
della media:
Pn
Pn
E [ i=1 tsi ]
λ
i=1 E [tsi ]
P
P
=
ρ=
=
n
n
µ
E [ i=1 tai ]
]
E
[t
ai
i=1
8
1.4
Serventi Multipli
In ogni istante di tempo più di un job può essere in esecuzione contemporaneamente. Definiamo m il
numero di serventi, che possono essere ad esempio canali, processori, ecc. . .
E [q] è il numero medio di job nel centro. E [w] è il numero medio di job nella coda. Quindi:
½
E [w] + ρ
se m = 1
E [q] =
E [w] + mρ se m > 1
Dimostrazione E [q] è la somma tra il numero medio di job nella coda ed il numero medio di job nel
servente singolo (m = 1). Chiamiamo ρi la probabilità di avere un job nel centro. Il numero medio è la
somma pesata di np (n), allora il numero medio di job nel servente singolo sarà pari a:
ρ=
+∞
X
mp (i) = 1 − p (0)
i=1
ovvero la percentuale di tempo di occupazione. Questo è anche il metodo di calcolo di ρ quando λ e µ
non sono direttamente noti. Nel caso in cui m > 1 allora ho mp job in elaborazione e quindi:
E [tq ] = E [tw ] + E [ts ]
Se vediamo ρ come il rapporto tra la frequenza media in arrivo e la frequenza massima in uscita, allora
è intuitivo capire che il ρ dell’intero centro è:
ρ=
λ
mµ
se m > 1
e che per quanto riguarda il singolo centro (che ha in ingresso un flusso
ρi =
per m > 1.
9
λ
mµ
λ
m ),
il ρi è sempre:
2
Leggi del modello a coda
2.1
Teorema di Little
Esiste un teorema fondamentale che lega i valori medi tra w e tw , e tra q e tq . Ha un’applicabilità molto
ampia, la sola condizione è che gli arrivi siano descritti secondo la legge di Poisson. Mentre la legge dei
servizi può essere di tipo generale. È applicabile ad un centro con servente singolo o multiplo.
Sia S un sistema generico, le grandezze in gioco sono:
• la frequenza di job in arrivo,
• il numero medio di job nel sistema np ,
• il tempo medio speso dal job nel sistema.
Il teorema di Little dice:
Legge di Little:
1a Definizione
Il numero medio di job nel sistema (in un certo intervallo) è pari al prodotto della frequenza
media degli arrivi con il tempo medio speso nel sistema.
Nel caso di centro singolo abbiamo:
½
E [w] = λE [tw ]
E [q] = λE [tq ]
½
E [n] = γE [tr ]
PM
γ = i=1 γi
Mentre in un sistema di centri otteniamo:
dove:
• γ rappresenta il flusso in ingresso al sistema proveniente dall’esterno.
Questo può anche essere nullo perché ci sono centri non connessi all’esterno.
• E [tr ] è il tempo medio di permanenza nel sistema.
• E [n] è il numero medio di job nel sistema.
Di conseguenza otteniamo le seguenti relazioni:
(
E [tw ] = E[w]
λ
E [tq ] = E[q]
λ
Dalla legge di Little si ricava che il tempo di risposta del sistema è pari a:
M
E [tr ] =
M
E [n] X E [ni ] X λi
=
=
E [tqi ]
γ
γ
γ
i=1
i=1
dove λi è il flusso in arrivo ad un centro, sia interno che esterno.
La legge di Little può anche essere enunciata nel seguente modo:
Il tempo che un job spende all’interno della rete è la somma dei tempi che spende in ogni
singolo centro E [tqi ], ognuno pesato per un fattore dato da λγi , ovvero il numero medio di
visite in quel centro.
Quindi λi è il throughput del centro in condizioni stazionarie, ovvero considerando tempi molto lunghi.
γ rappresenta il throughput della rete. Infine il rapporto λγi indica il numero medio di visite che il job fa
in quel centro durante la sua permanenza nella rete.
10
Legge di Little:
2a definizione
2.2
2.2.1
Leggi fondamentali del centro singolo
Notazione di Kendall
È una notazione sintetica per indicare le informazioni principali di un centro:
A/B/m/n/p/z
dove:
• Il parametro A determina il tipo di distribuzione dei tempi di interarrivo ta , indichiamo con M la
legge esponenziale con tempi di arrivo Poissoniani.
• Il parametro B rappresenta il tipo di distribuzione dei tempi di servizio ts .
Possiamo avere:
– G: generale,
– D: deterministico,
– M : esponenziale,
– Hh : Iper-Esponenziale con h stadi,
– Ek : K-Erlang
• Con il parametro m rappresentiamo il numero di serventi.
• n è la capacità della coda.
• p è la capacità della sorgente.
• Z rappresenta la disciplina di servizio, dove se non specificata allora si assume una disciplina
astratta.
2.2.2
Caso M/G/1
In questo caso abbiamo un centro a processore singolo, distribuzione del tempo di interarrivo esponenziale
e distribuzione del tempo di servizio generale.
La soluzione per E [w] è data Khinchin – Pollaczek (KP):
·
¸
σ 2 (ts )
ρ2
1+ 2
E [w] =
2 (1 − ρ)
E (ts )
La relazione vale per M/G/1 con discipline di servizio astratte, come LIFO, FIFO, RAND, ovvero con
scheduling che non fa scelte in base al tempo chiesto dal job (job-size) e non-preemptive.
E [w] cresce con ρ ed il rapporto tra la varianza e la media quadrata. Tale rapporto indica la
dispersione dei tempi intorno alla media. Pertanto più i tempi sono dispersi tanto più la coda cresce,
ovvero la congestione è direttamente proporzionale alla dispersione dei tempi di servizio. Ad esempio se
siamo in presenza di burst di arrivi oppure di job molto grandi.
2.2.3
Caso M/D/1
Dalla notazione di Kendall abbiamo un centro a processore singolo, distribuzione del tempo di interrarivo
esponenziale e distribuzione del tempo di servizio deterministica.
Dato che i tempi di servizio sono deterministici allora otteniamo una varianza nulla, pertanto sostituendo
alla formula KP σ 2 (ts ) = 0 si evince che:
E [w] =
ρ2
2 (1 − ρ)
Questo rappresenta il caso ottimo con E [w] minimo.
11
KhinchinPollaczek
2.2.4
Caso M/M/1
Abbiamo un centro a processore singolo, distribuzione del tempo di interarrivo e di servizio esponenziali.
La varianza è il quadrato della media quindi:
(
ρ2
ρ2
E [w] = 2(1−ρ)
(1 + 1) = 1−ρ
σ 2 (ts ) = E 2 [ts ]
In questo caso la coda risulta essere il doppio del caso precedente.
2.2.5
Caso M/Ek /1
Abbiamo un centro a processore singolo, distribuzione del tempo di interarrivo esponenziale e distribuzione del tempo di servizio K-Erlang.
La varianza risulta essere k volte più piccola di quella esponenziale, quindi si ottiene:
(
£
¤
ρ2
E [w] = 2(1−ρ)
1 + k1
σ 2 (ts ) =
E 2 [ts ]
k
Se k = 1 allora ci ritroviamo nel caso di una M/M/1, mentre al crescere degli stadi k allora il rapporto
1
k tende ad essere nullo e quindi abbiamo un comportamento simile a quello di una M/D/1.
2.2.6
Caso M/H2 /1
Nel caso di un centro a processore singolo, distribuzione del tempo di interarrivo esponenziale e distribuzione del tempo di servizio Iper-Esponenziale a due stadi.
La varianza è ancora più grande dell’esponenziale, ovvero:

ρ2

 E [w] = 2(1−ρ) [1 + f (p)]
ρ2
1
→ E [w]H2 =
σ 2 (ts ) = f (p) E 2 [ts ]

2
(1
−
ρ)
2p
(1
− p)
1
 f (p) =
2p(1−p) − 1
dove p è la probabilità di scegliere uno dei due stadi. Quindi la varianza dipende da quanto sono lontane
le probabilità di scegliere uno stadio o l’altro.
Esempio
Sia E [ts ] = 1 sec e λ = {0.1, 0.2, . . . , 0.9}. Studiare l’andamento di E [tw ] al crescere della frequenza di
arrivo (da 0.1 a 0.9). La legge degli arrivi è di Poisson, mentre la distribuzione dei servizi è esponenziale.
ρ=
λ
= λE [ts ] = λ
µ
ρ2
E [ts ] ρ
E [w]
=
=
λ
λ (1 − ρ)
1−ρ
Si nota che per valori piccoli di ρ la curva esplode.
E [tw ] =
12
2.2.7
Andamento delle variabili di uscita
Esempio
Impianto monoprocessore con tempi di servizio E [ts ] = 0.5 sec e disciplina di servizio astratta. Il
flusso di richieste è di tipo Poissoniano con frequenza λ = 0.6, 1, 1.4, 1.8. Stimare l’andamento degli
indici di prestazione nel caso in cui la distribuzione dei tempi di servizio sia esponenziale, K-Erlang,
Iper-Esponenziale, deterministica a parità di media.
La seguente figura applica le precedenti formule per E [w].
Applicando la legge di Little, da E [w] possiamo ottenere E [q] e di conseguenza E [tw ] e E [tq ]. Si nota
che l’andamento di tali variabili rispecchia quello di E [w] rispetto a ρ.
In generale l’andamento della E [w] rispetto a ρ sarà:
E [w]det ≤ E [w]Ek ≤ E [w]exp ≤ E [w]H2
di conseguenza sono valide anche le seguenti relazioni:
E [q, tq , tw ]det ≤ E [q, tq , tw ]Ek ≤ E [q, tq , tw ]exp ≤ E [q, tq , tw ]H2
Stesso discorso vale per le varianze:
2
σdet
³q´
w
<
2
σE
k
³q´
w
¡q¢
2
³q´
³q´
σexp
w
2
2
=
< σH
< σexp
2
k
w
w
Per un dato valore di ρ la varianza minima si riscontra con servizi costanti, la massima per gli IperEsponenziali, le curve tendono all’infinito per ρ → 1 e sono indipendenti dalla disciplina.
Di conseguenza otteniamo i seguenti risultati:
2
2
2
2
σdet
(w, q, tw , tq ) ≤ σE
(w, q, tw , tq ) ≤ σexp
(w, q, tw , tq ) ≤ σH
(w, q, tw , tq )
2
k
13
2.3
2.3.1
Sensibilità ai fattori ed alle discipline
Sensibilità ai fattori
Abbiamo visto nel caso di una distribuzione esponenziale che se ρ è abbastanza grande (già a 0.7), un
piccolo aumento di λ porta ad un piccolo aumento di ρ ma comporta un grande incremento di E [q]. Ciò
diventa più evidente quando ρ tende a 1.
Questo è molto importante per capire le fasi di picco del carico che possono portare ad un collasso
del sistema. Infatti se abbiamo un centro M/G/1, esso manifesta una sensibilità al traffico di ingresso
progressivamente crescente con ρ. Se progettando tale centro, si prevede un coefficiente di utilizzazione
(ρ) dell’ordine dell’80%, occorre anche prevedere che un un piccolo aumento nella frequenza degli arrivi
(λ) potrà causare gravi degradazioni nel comportamento del centro.
Si dimostra che un piccolo aumento di λ corrisponde ad un aumento della popolazione del centro che
è circa un fattore costante aE [ts ], cioè:
δE [q] ∼
= aE [ts ]
δλ
Esempio
Se abbiamo una densità esponenziale con ρ = 0.5. Se aumenta un poco λ (del 0.5% ad esempio) allora
E [q] aumenta di circa 4E [ts ] volte. Per ρ = 0.9 l’aumento è di 100E [ts ] volte, come si vede nella seguente
figura.
In formule, sappiamo che per un sistema a centro singolo:
E [q] = E [w] + ρ
In particolare, nel caso M/M/1 abbiamo:
E [q] =
ρ2
ρ
+ρ=
1−ρ
1−ρ
Dalla legge di Little sostiuiamo ρ con λ/µ, ed otteniamo:
E [q] =
λ
µ
1−
λ
µ
14
=
λ
µ−λ
A questo punto facciamo la derivata per λ:
δE [q]
=
δλ
δ
h
λ
µ−λ
δλ
i
µ
=
2
(µ − λ)
Dato che nell’esempio non conosciamo nè il valore di λ nè di µ allora la formula trovata la scriviamo in
termini di ρ e di E [ts ], ovvero:
µ
2
(µ − λ)
=
1
µ (1 − ρ)
2
=
E [ts ]
(1 − ρ)
2
Quindi il coefficiente a è pari, nel caso dell’esponenziale a:
a=
1
(1 − ρ)
2
Questo comportamento vale per ogni distribuzione che esplode dopo un certo ρ.
2.3.2
Sensibilità alle discipline
Per quanto riguarda la sensibilità alle discipline, sappiamo che la KP vale per ogni disciplina astratta
(M/G/1), pertanto gli indici di qualità sono indifferenti al cambiamento della disciplina, purché sia
sempre astratta:
E [w, q]F IF O = E [w, q]LIF O = E [w, q]RAN D
σ 2 (w)F IF O = σ 2 (w)LIF O = σ 2 (w)RAN D
Se la media e la varianza sono identiche allora la forma della distribuzione è identica, passando da una
disciplina ad un’altra abbiamo la stessa distribuzione della E [w] e E [q].
Con i tempi si ottiene:
E [tw , tq ]F IF O = E [tw , tq ]LIF O = E [tw , tq ]RAN D
2
σ (tw , tq )F IF O ≤ σ 2 (tw , tq )RAN D ≤ σ 2 (tw , tq )LIF O
Mentre le medie sono sempre uguali, le varianze cambiano ed essendo la varianza un indice di qualità
la disciplina astratta migliore è la fifo, poi rand ed infine la lifo. Ad esempio, supponiamo di avere
un algoritmo di scheduling che migliora di 100 volte quello di attesa. Bisogna prima di tutto valutare
il tempo di servizio. Infatti, se questo è molto più grande del tempo di attesa, allora non ha senso
migliorare E [tw ]. Di solito E [ts ] << E [tw ], ma può non essere cosı̀ nel caso multiservente.
Per trovare manualmente la veridicità di tali grandezze si utilizza la KP per trovare E [w] e tramite
la legge di Little troviamo le restanti grandezze.
2.4
Tempo di attesa e tempo rimanente di servizio
Sia dato un centro M/G/1, immaginiamo che la coda non sia vuota ed arriva un job U . Il job dovrà
attendere un tempo che dipende da due fattori chiamati componenti di attesa:
1. Il tempo rimanente al job servito in quell’istante.
2. Il tempo per completare i job che secondo la disciplina usata sono prima di lui.
Quindi il tempo di attesa tw corrisponde alla somma del tempo rimanente del job che è in servizio (tsrim )
con il tempo richiesto per servire i job in coda prima di U (tqueue ):
15
tw = tqueue + tsrim
dove tutte le variabili sono grandezze medie.
Vedremo ora come esprimere una relazione che lega il tempo medio di attesa E [tw ] con il tempo
rimanente. Si dimostra che il tempo medio rimanente “visto” dall’arrivo è:
£ ¤
λE t2s
E [tsrim ] =
2
Per dimostrare la formula precedente usiamo la legge di Little e la formula KP applicata ad E [tw ]:
·
µ
¶¸
E [w]
σ 2 (ts )
ρ2
1
E [tw ] =
1+ 2
=
λ
λ 2 (1 − ρ)
E [ts ]
dove:
½
£ ¤
σ 2 (ts ) = E t2s − E 2 [ts ]
ρ2 = λ2 E 2 [ts ]
Quindi:
E [tw ] =
=
1
λ
·
λ2 E 2 (ts )
2(1−ρ)
µ
¶¸
E [t2s ]−E 2 [ts ]
1+
E 2 [ts ]
t2s
1 λ E (ts ) E [ ]
λ 2(1−ρ) E 2 [ts ]
2
2
=
t2s
λE [ ]
2(1−p)
=
=
E [tsrim ]
1−ρ
1
Bisogna porre attenzione al fatto che tqueue 6= 1−ρ
, ma è solo il termine che tiene conto del tempo
necessario per servire i job prima di U .
Se ρ → 0, il job che arriva non trova code, ovvero E [tw ] = E [tsrim ]. Mentre se ρ → 1, allora E [tw ] → ∞
infatti la coda è infinita.
Nel caso di distribuzione esponenziale abbiamo:
½ £ 2¤
E ts = 2E 2 [ts ]
E [tsrim ] = ρE [ts ]
Infatti se ρ → 0, allora E [tsrim ] → 0 e non trova code, quindi con buona probabilità trova il centro
libero.
2.5
Utilizzazione
L’utilizzazione è una frazione di tempo durante il quale il centro sta lavorando.
Se λ < µ il sistema è in grado di smaltire le richieste. Sia T il periodo di osservazione e B il periodo di
occupazione durante T allora l’utilizzazione sarà pari a:
U =ρ=
B
T
Sia C il numero di completamenti in T allora il throughput è pari a:
X=
C
T
Se separiamo quest’ultima formula otteniamo che:
X=
C
CB
=
= µU
T
BT
16
quindi il rapporto B
C = E [ts ].
Per work in system si intende l’avanzamento del lavoro svolto. È dato dalla quantità di job e da quanto
chiedono al sistema.
Una disciplina di scheduling è work-conserving se esegue il lavoro quando ci sono job nel sistema (ovvero
non spreca lavoro). Tutte le discipline work-conserving producono lo stesso work in system.
Supponiamo di avere discipline diverse, per ogni istante di tempo producono lo stesso work in system
dato lo stesso tasso di arrivi, ma non hanno lo stesso tempo di servizio. Ad esempio consideriamo due
sistemi A e B. Il sistema A serve sempre il job più piccolo, mentre il sistema B possiede lo stesso work
in system di A. Di conseguenza E [q]A < E [q]B perché in termini di numerosità il sistema A smaltisce
un maggior numero di job. Quindi il tempo di risposta di A è più basso rispetto a B.
Dato che queste discipline non necessariamente producono lo stesso tq , allora E [tq ] tende ad essere
rappresentativo di “alcuni job” con grande job-size. Cioè vuol dire che nel sistema che lo slowdown
medio (come definito di seguito) migliora con un gran
h i numero di job piccoli.
t
Lo slowdown medio è per definizione pari a E tqs ≥ 1 con ts = X. È preferibile che solo job piccoli
abbiano tq piccolo, quindi che tq e X siano proporzionali.
Lo slowdown è un indice utile perché valori piccoli forniscono indicazioni anche sul valore massimo. In
altre parole, definendo lo slowdown medio, si definisce di conseguenza anche lo slowdown massimo, ovvero
pochi job hanno tempo di risposta molto più maggiore del tempo di servizio richiesto. Ad esempio se
E [sd] = 2 non possono esserci molti job con slowdown pari a 3 e non possono essere più della metà. Solo
1/4 dei job possiede slowdown maggiori a 5.
Mentre il tq è fortemente condizionato dai job grandi, per lo slowdown è il contrario dato che il rapporto
tq /X cresce se X è piccola. Se si ha una distribuzione heavy tailed, migliorando il tq si migliora solo
l’1% dei job grandi, invece con lo slowdown si ottengono miglioramenti più significativi.
Si nota che le discipline che servono prima i piccoli job permettono di abbassare lo slowdown medio, ma i
grandi job vanno in starvation, ovvero sono job pronti ma non eseguiti. Di conseguenza un job è starved
se il suo slowdown è eccessivamente alto. Pertanto contano molto leprestazioni dei job piccoli, perché
tendono ad avere slowdown grandi.
E
·
¸
¸
·
E [tq (x)]
tq (x)
tq
=
|JobSize = x = E [sd (x)] = E
JobSize
x
x
Dalla formula precedente si nota che il tempo di risposta è lineare in x e lo slowdown è peggiore al
crescere del carico. Nel caso di una politica fifo, lo slowdown è alto per piccoli job e decresce al crescere
del job-size.
Consideriamo il caso in cui arrivano n job all’istante t = 0 ed ognuno chiede 1. Il sistema A ha disciplina
ps, mentre il sistema B ha disciplina fifo. Nel sistema A, dopo t = n ci sono tutti i job, ovvero i job
entrano tutti insieme. Nel caso del sistema B, il primo job esce dopo 1, il secondo dopo 2, il job n esce
dopo t = n. Ciò vuol dire che nel sistema B tutti i job migliorano tq tranne il primo ma nessuno peggiora
il tempo di risposta.
E [sd] =
Z
E [sd (x)] f (x) dx =
x
Z
x
E [tq (x)]
f (x) dx
x
Consideriamo ora discipline non-preemptive e non basate su job-size, ad esempio fifo, lifo e random.
Queste hanno tutte la stessa distribuzione del numero di job nel sistema, quindi stessa media e varianza.
Ma se consideriamo la dimensione del job, tale assunzione non è più vera. Infatti questa condiziona la
distribuzione di q.
w
q
tq
tw
Medie
lifo = rand =
fifo
lifo = rand =
textscfifo
Varianze
lifo = rand =
fifo
fifo < rand <
lifo
Passiamo ora a discipline preemptive senza job-size, come la ps, lifo con prelazione o fb, vale che:
17
Work
System
in
Work
Conserving
Slow-Down Medio
(
³
´
σ 2 (ts )
ρ2
£ ¤
λ2
E [w] = 2(1−ρ)
1+ E
2 (t )
s
E t2s
⇒ E [w] =
¤
£
2
2
2
2
(1
−
ρ)
σ (ts ) = E ts − E [ts ]
Inoltre usando la legge di Little otteniamo:
£ 2¤
λ
E [w]
2 E ts
=
E [tw ] =
λ
1−ρ

2
λ
E
t
 E [sd (x)] = E[tq (x)] = 1 + 2 [ s ]
x
x(1−ρ)
 E [t (x)] = E [x + t (x)] = x + E [t ] = x +
q
w
w
[t2s ]
1−ρ
λ
2E
Se la distribuzione del job-size è altamente variabile, lo slowdown sarà molto grande per i job molto
piccoli. Pertanto per ridurre lo slowdown medio, bisogna ridurre il tempo di attesa dei job piccoli. Se
non si conosce il job-size bisogna utilizzare le discipline preemptive.
2.6
Processor Sharing (PS)
La seguenza di arrivo è data dalla somma della sequenza dei tempi di arrivo con la dimensione del job.
La disciplina ps si comporta meglio della fifo, infatti è la disciplina considerata fair (equa) per
eccellenza. In media ci sono dei casi per i quali la ps è peggiore per tq e per lo slowdown medio in base
alla sequenza di arrivo.
Le formule da applicare nel caso della PS sono:

M/G/1/P S
M/M/1/F IF O

P (q = n)
= ρn (1 − ρ) = P (q = n)



M/G/1/P
S
M/M/1/F
IF
O
ρ

= 1−ρ
= E [q]

 E [q]
M/G/1/P S
M/M/1/F IF O
E[ts ]
E [tq ]
= 1−ρ = E [tq ]


 E [tq (x)]M/G/1/P S = x

1−ρ



M/G/1/P S
1
= E [sd]
E [sd (x)] = 1−ρ
Si nota che la lunghezza media del busy period è dipendente da x, il contrario vale per lo slowdown.
Ovvero lo slowdown medio per tutti i job è lo stesso poiché è indipendente dal job-size.
2.7
Hazard Rate Function
Data una variabile continua X, l’hazard rate function è data dal rapporto tra f (t) e F (t):
r (t) =
f (t)
F̄ (t)
dove F̄ (t) è il complemento della cumulativa, ovvero è pari a P (x > t).
La probabilità che fallisca X (tempo di vita) in un infinitesimo di tempo δt è pari a:
P (x ∈ (t + dt) |x > t) =
P (x ∈ (t, t + dt))
f (t)
dt
∼
P (x > t)
F̄ (t)
Per l’esponenziale, si ottiene r (t) = λ, ovvero è costante. Ciò è legato alla proprietà memoryless della
distribuzione.
Esempio
Qual’è la probabilità che X ∈ (t, t + ∆t) sapendo che X > t?
P (X ∈ (t, t + ∆t) |X > t) =
f (t)
P (t, t + ∆t)
dt = r (t) dt
=
P (X > t)
F̄ (t)
18
Esempio
Sia una distribuzione esponenziale di media 10 min, ad esempio il tempo speso da un cliente in media
in una banca. La probabilità di tempo in cui un utente sta in banca per più di 5 min è pari a: F̄ (s) =
5
e− 10 = e−0.5 .
Ovvero P (tempo speso in banca > 15|cliente ancora in banca dopo 10 min).
2.8
LIFO con prelazione (non job-size)
Data una M/G/1, con scheduling astratto, la soluzione analitica ci è data dalla KP, che ci fornisce la
E [w]. Il tq , sopratutto con distribuzioni heavy tailed, è influenzato molto dai job grandi, basti pensare
che l’1% influisce sul 50% del carico, migliorando il tq di pochi job.
Per questo motivo usiamo lo slowdown, anche condizionato alle varie job-size. Questo indice è condizionato molto dai job piccoli quindi se lo miglioriamo, otteniamo miglioramenti sulle prestazioni di molti
job piccoli.
Per migliorare le prestazioni dei job piccoli senza conoscere la dimensione dei job si usa la ps, cosı̀ i
job che chiedono poco avanzano abbastanza velocemente. Infatti nelle discipline non size based come
ps, lifo con prelazione e fb, lo slowdown della ps è uguale nel caso condizionato e in generale è un pò
l’ottimo al quale si tende.
Supponiamo che:
• il job n sia in esecuzione;
• arriva il job n + 1;
• il job n viene interrotto;
• il job n + 1 va in esecuzione.
dove queste operazioni si ripetono ad ogni arrivo di un nuovo job.
Il tempo di attesa del job n corrisponde al tempo di attesa medio di un busy period, ovvero:
E [lunghezza interruzione] = E [lunghezza busy period] =
E [ts ]
1−ρ
dove ρ è il fattore proporzionale al livello di occupazione del centro.
In realtà, possono esserci anche più interruzioni del job n. Siccome la dimensione del job è x, il numero
di volte medio che può essere interrotto è λx.
Con la disciplina lifo, il tw è più che altro un wasted time, ovvero il tempo che il job è nel sistema e
non riceve servizio. In formule, per un job x il wasted time, tempo di risposta e slowdown sono pari a:

E[ts ]

 E [wt (x)] = E [n. interruzioni] E [lunghezza interruzione] = λx 1−ρ =
x
E [tq (x)] = x + E [wt (x)] = 1−ρ

 E [sd (x)] = E[tq (x)] = 1
x
xρ
1−ρ
1−ρ
Si nota che lo slowdown ed il tempo di risposta sono identici a quelli della disciplina ps (vedi paragrafo
2.6). Ma vi è una fondamentale differenza tra queste due discipline, ovvero nel caso della lifo abbiamo
per ogni job in arrivo solo due prelazioni, una per sospendere il job attualmente in esecuzione ed una per
riprendere il job che è stato sospeso; mentre la disciplina ps possiede un numero superiore di prelazioni
poiché fornisce un servizio “simultaneo”. Ciò genera un maggiore overhead nel sistema.
Per ridurre ulteriormente lo slowdown dei job piccoli senza conoscere la job-size si può utilizzare il tempo
di permanenza di un job nel sistema (anzianità del job). Infatti, si possono fare delle supposizioni sul
job-size:
• fr (failure rate): viene data la precedenza ai job più giovani perché più grande è l’età del job e
più grande è il suo tempo rimanente di esecuzione.
19
Wasted Time
• dfr (decreasing failure rate): tanto è più grande il job, tanto più potrebbe essere grande il tempo
rimanente (come nei sistemi Unix). Pertanto viene data la precedenza ai job più giovani.
• ifr (increasing failure rate): viene data la preferenza ai job più anziani perché i job più giovani
hanno un tempo di esecuzione più lungo.
• fr costante: non viene fatta alcuna preferenza poiché i tempi rimanenti sono indipendenti dall’anzianità (caso esponenziale).
• fb (generalized foreground-background scheduling): si hanno due code, i job che arrivano vanno
nella prima coda e sono serviti con la disciplina ps.
Dopo un certo tempo, passano nella seconda coda e vengono serviti solo se la prima coda è vuota.
Quindi i job di anzianità più bassa vengono serviti prima.
Il miglioramento rispetto alla disciplina ps dipende dalla previsione sul tempo rimanente. Infatti
se la distribuzione è:
– dfr:
FB
< E [tq ]
FB
> E [tq ]
FB
= E [tq ]
E [tq ]
PS
– ifr:
E [tq ]
PS
– fr costante:
E [tq ]
PS
Ma in questo caso lo slowdown si comporta meglio con la fb perché ci sono molti job piccoli nel
sistema e lo scheduling fb avvantaggia i job con tempo rimanente più piccolo:
FB
E [sd]
PS
< E [sd]
Esempio
Sia un sistema M/M/1/F IF O con:

µ = 5 job/sec


 E [t ] = 0.2 sec
s
λ
=
2.5 job/sec


 E £t2 ¤ = 2 = 0.08
s
µ2
Calcolare lo slowdown medio al variare di x.
λ
2E
£ 2¤
ts
E [sd (x)] = 1 +
(1 − ρ) x
Dai dati forniti otteniamo ρ = 0.5, da cui otteniamo:
E [sd (1)]
E [sd (2)]
E [sd (3)]
E [sd (4)]
E [sd (5)]
ρ = 0.5
1.2
1.1
1.6̄
1.05
1.04
20
ρ = 0.8
1.8
1.4
1.26̄
1.2
1.16
(
PS
1
=2
E [sd (x)] = 1−ρ
E[ts ]
E [tq ] = 1−ρ = 0.4
Lo slowdown, al crescere della size, tende a 1. È piuttosto piccolo, addirittura più bassa della disciplina
ps. Anche aumentando ρ lo slowdown rimane molto piccolo.
Ciò è dovuto dal fatto che rispetto ad E [ts ] = 0.2, la dimensione dei job è molto grande, perciò lo
slowdown risulta molto piccolo. Infatti il tempo di attesa, rispetto a quello che viene richiesto da un job,
è piccolo.
2.9
Heavy Tail
Le probabilità di avere tempi di servizio che superino una certa soglia è molto grande.
La distribuzione Pareto è descritta dalla seguente distribuzione di probabilità:
f (x) = αk α x−α−1
k≤x≤∞
dove k è il parametro di scala che limita la variabile ed indica il tempo di servizio minimo, mentre α
indica la dissimetria della distribuzione.
La sua media è pari a:
E [x] =
αk
α−1
tale formula rappresenta anche il primo momento e si definisce solo se α > 1. Più in generale abbiamo:
con α > i.
La sua varianza è pari a:
£ ¤
αk i
E xi =
α−i
σ 2 (x) =
αk 2
2
(α − 1) (α − 2)
con α > 2.
Questa è una distribuzione di tipo dfr. Ovvero una piccola percentuale di job produce una grande
quantità di carico. Ad esempio, l’1% dei job che chiedono un tempo di servizio lungo sono molti e
producono un carico elevato (circa 50%). Al contrario, usando una distribuzione esponenziale, l’1% dei
job generano un carico del 5%.
Quindi il comportamento osservato per un job che usa tale tipo di distribuzione è quello che usa la cpu
nei sistemi Unix. La probabilità che il servizio continui dopo un certo tempo cresce nel tempo.
2.9.1
Bilanciamento del carico in una rete di workstation
Se abbiamo distribuzioni heavy tail, i job più vecchi sono quelli che avranno il tempo rimanente più
lungo. Inoltre, poiché l’1% dei job producono un carico elevato, basta migrare i job più “giovani” che
avranno una minore storia passata (meno dispendioso per la migrazione dello stato).
Definiamo la grandezza per il qos è la probabilità che il tempo di coda superi una certa soglia, ovvero
P (tq > t).
21
Distribuzione
Pareto
Esempio
In questo esempio vediamo come viene assegnato il task in un sistema distribuito. Le possibili applicazioni
sono: il bilanciamento del carico ai siti web (job interrompibili) oppure assegnamento dei task ai server
dei supercomputer (job non interrompibili).
Supponiamo che gli host siano identici e che ogni job ne usi uno solo e poi esca. La politica di assegnamento dei task dovremmo usare per minimizzare il tempo di risposta (tap - task assignament
problem):
1. random;
2. round-robin;
3. shortest-queue: seleziona l’host con la coda più libera;
4. central-queue: l’host appena si libera sceglie un job da servire;
5. least-work in queue: seleziona l’host con il minor carico, dipendente anche dal size-job;
6. central-queue shortest job: seleziona il job con size minima;
7. size based policy: selezioniamo i job in base a ciò che i job chiedono.
Le ultime tre politiche sono implementabili solo conoscendo la dimensione del job.
Nel caso di job non interrompibili, per job-size realistici si comportano meglio politiche di sbilanciamento
del carico. Mentre nel caso di job interrompibili si comportano meglio le politiche di bilanciamento
del carico per diminuire il tempo di risposta medio o in alternativa otteniamo dei miglioramenti con le
politiche di sbilanciamento del carico se si vuole minimizzare il rallentamento medio di un job (slowdown).
Esempio
Il tempo di risposta medio per politiche astratte, ovvero non basate sul job-size, è analiticamente lo
stesso per tutte e 3 le politiche (fifo, non-preemptive lifo e random). Nella preemptive-lifo, il job
quando arriva non aspetta. Ciò dipende dalla variabilità del tempo medio di servizio. Se la varianza è
alta questa si rivela la disciplina migliore.
Teorema limite Siano n processi in arrivo di pacchetti indipendenti e identicamente distribuiti secondo
λ/n, l’aggregato è un processo di Poisson di frequenza λ.
22
3
Discipline dei modelli a coda
3.1
Centro singolo con disciplina prioritaria
Le discipline a priorità sono quelle in cui gli utenti vengono serviti in base a priorità fisse precedentemente
assegnate.
Il flusso λ in arrivo viene diviso in diverse code. Abbiamo r code di priorità, ognuno con disciplina
astratta. Per convenzione si denonima 1 la priorità più alta. I job con priorità 1 saranno serviti prima
di tutti gli altri. Una volta che la coda è vuota si passa a servire i job nella coda a priorità 2, e cosı̀ via.
Se
un job con priorità k, le code con priorità da 1 a k − 1 devono essere vuote. Naturalmente
Pservo
r
λ = i=1 λi .
All’interno della stessa coda i job vengono serviti con disciplina FIFO e tra code quelli con priorità più
alta.
Le discipline prioritarie possono essere astratte o dipendenti dal tempo:
• Astratte: le classi sono formate secondo un criterio astratto, ovvero se gli utenti sono ripartiti tra
i vari livelli sulla base di criteri non dipendenti dalla durata del tempo di servizio (ts ).
Ad esempio, divido il flusso in maniera uniforme
λ
r.
• Dipendenti dal tempo (ts ): Mando prima in esecuzione i job che richiedono meno (funziona bene),
ovvero se ad ogni livello si fanno entrare utenti che richiedono un ts compreso in un certo intervallo.
Ad esempio, ts è inferiore alla media che hanno priorità 1, ts maggiore alla media che hanno priorità
2.
Le discipline basate su priorità possono essere con prelazione o meno:
• senza prelazione: l’arrivo non interrompe il servizio in corso;
• con prelazione: se in un certo istante di tempo il job u′ in arrivo possiede una priorità k ′ più alta
del job attualmente in esecuzione (k ′ < k) allora si interrompe il servizio in corso e viene gestito il
job u′ con maggiore priorità.
Quando u′ termina se nel frattempo non è arrivato nessun job con priorità più alta viene ripreso il
job con priorità k.
3.2
3.2.1
Discipline senza prelazione
Priorità astratta senza prelazione (PASP)
Il servente serve prima la coda 1, poi la 2, ecc. . . ma senza prelazione. Definiamo i parametri relativi alla
classe k con 1 ≤ k ≤ r:
λk frequenza media degli arrivi a livello k.
tsk il tempo di servizio richiesto dei job di classe k.
23
E (tsk ) =
1
µk
la media di tsk .
σ 2 (tsk ) la varianza di tsk .
ρk =
λk
µk
l’utilizzazione del centro da parte del livello k.
In particolare, se ts è uguale in ogni livello, ovvero per discipline astratte, si ottiene:
E [tsk ] = E [ts ] , σ 2 (tsk ) = σ 2 (ts )
In riferimento ad un job u in arrivo con classe k posso affermare che E [twk ] dipende da tre fattori detti
componenti di attesa:
• Tempo medio necessario per completare il job in corso tsrim .
• Tempo medioP
necessario per completare tutti i job che hanno priorità più alta, ovvero da 1 a k − 1
k−1
che è pari a: i=1 ts .
• Inoltre durante l’attesa del job u dovuto ai precedenti punti possono esserci dei nuovi arrivi in coda.
Questi se hanno priorità maggiore devono essere serviti
prima del job u, quindi bisogna contare
Pk−1
anche il tempo medio per servire questi job, ovvero:
i=1 ts .
Date le precedenti componenti di attesa, il tempo medio di attesa di un job di classe k è pari a:
E [twk ] = ³
1−
λ
t2
2E
´³s
Pk
i=1 ρi
£ ¤
1−
Pk−1
i=1
ρi
´
Si nota che la ripartizione dei tre tempi non è descrivibile a partire da questa formula. I tempi tsk sono
tutti uguali tra loro perché siamo in discipline astratte. Il tempo di attesa non può essere infinito con
disciplina uniforme perché non si otterrà mai un flusso molto più grande in una classe rispetto alle altre,
prostrei avere comunque attese molto lunghe.
La seguente relazione è sempre vera:
£
¤
E [twk ] ≤ E twk+1
Possiamo inoltre calcolare a partire da E [tsk ] le altre grandezze:
• Lunghezza media della coda di livello k si calcola utilizzando la legge di Little:
E [wk ] = λk E [twk ]
• Numero medio di job di classe k nel centro:
E [qk ] = E [wk ] + ρk
• Per quanto riguarda invece il centro nella sua interezza, il tempo medio di attesa globale (tempo
medio di attesa di un qualsiasi job, di classe qualsiasi) devo usare la formula KP perché ci troviamo
in presenza di una disciplina astratta:
E [tw ] = E [E [twk ]] =
r
X
pk E [twk ]
k=1
Con pk probabilità di essere di classe k, abbiamo pk =
λk
λ .
Esempio
Dimostrare che E [tw ]P ASP = E [tw ]KP .
Dato che la KP vale per tutte le discipline astratte, allora vale anche per la pasp.
24
Esempio
Sia
• Il flusso in arrivo λ ∈ {0.1, 0.2, 0.4, 0.6},
• Mono servente a 4 classi di priorità,
• Il tempo di servizio ha distribuzione esponenziale ed è pari a E [ts ] = 1 sec.
Si studi al variare di λ l’andamento del tempo medio di attesa di ogni classe di priorità.
e che E [w] =
Per calcolare il tempo di attesa di un job di priorità k, sappiamo che E [tw ] = E[w]
λ
nel caso di distribuzione esponenziale. Quindi il tempo di servizio rimanente è pari a:
E [tsrim ] =
ρ2
1−ρ
ρ2
= ρE [ts ]
λ
Da quest’ultima formula si può riscrivere il tempo di attesa di un job di priorità k come:
E [twk ] = ³
1−
ρE [ts ]
´³
Pk−1 ´
1 − i=1 ρi
i=1 ρi
Pk
A questo punto si devono calcolare i vari ρi , per fare ciò ci avvaliamo delle seguenti formule:

λ
 λi = k
λi
ρi = µi

µ = µi = E[t1 s ]
ovvero supponiamo che il flusso di arrivi sia equamente ripartito tra le quattro code di priorità e che
avendo un unico servente abbiamo un unico µ.
I risultati ottenuti al variare di λ
λ
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
E [tw1 ]
0.1026
0.2105
0.324
0.4̄
0.5714
0.7059
0.84
1
1.1613
E [tw2 ]
0.108
0.2339
0.3816
0.5̄
0.7619
1.0084
1.3054
1.6̄
2.1114
E [tw3 ]
0.1138
0.2614
0.4554
0.7142
1.06̄
1.5584
2.2672
3.3̄
5.035
E [tw4 ]
0.120
0.2941
0.553
0.9524
1.6
2.72
4.9123
10
27.6923
Il risultato rappresentato nella seguente figura ci fa capire che al crescere di ρ le diversità dei tempi
medi di attesa fra le varie classi si fanno sempre maggiori.
25
3.2.2
Priorità basate su tempo senza prelazione (PTSP)
In questo caso, il meccanismo delle priorità funziona allo stesso modo di quello basato su discipline
astratte, ovvero il job che arriva deve attendere i job con priorità maggiore e quelli che nella sua coda
devono essere serviti prima. Quello che cambia è come si formano le classi.
In questo caso abbiamo r classi. Nella prima classe andranno i job con tempo di servizio minimo,
mentre nella classe r andranno i job con tempo di servizio massimo. I job brevi vanno in esecuzione
prima dei job lunghi e le code sono gestite con politica FIFO.
Quindi, date due classi h e k con h < k allora E [tsh ] < E [tsk ], dove ts ∈ [0, D].
Se dividiamo l’intervallo temporale di ts in r sotto intervalli allora il job u diventa di classe k se
tsk ∈ (dk−1 , dk ].
Mentre in pasp i tassi di arrivo λk sono fissati arbitrariamente e E [tsk ] = E [ts ], in ptsp i valori dei
λk e gli E [tsk ] dipendono dalla forma della distribuzione del tempo di servizio ts e da come si scelgono
gli intervalli (dk−1 , dk ].
La classe k sarà quella formata da tutti i job che hanno un tempo tra dk−1 e dk . Quindi la dimensione
della classe dipende da quanto è grande l’area sotto la curva di tale intervallo. Il valore di E [tsk ] è la
media dei tempi che appartengono nell’intervallo, e quindi è ottenibile in modo classico come:
(
R dk
E [tsk ] = dk−1
ts f n (ts ) dts
f n (ts ) =
f (ts )
F (dk )−F (dk−1 )
Tale funzione è normalizzata perché bisogna fare in modo che la somma delle probabilità di tutti i valori
deve essere 1, ovvero l’area sottesa all’intervallo sia unitaria. λk è quindi proporzionale al rapporto tra
l’area sottesa alla curva dell’intervallo e l’area totale, ovvero:
λk = λ [F (dk ) − F (dk−1 )]
Detto ciò, possiamo vedere nel caso ptsp il tempo di attesa della classe k. Dal punto di vista concettuale
i termini sono gli stessi della pasp, ovvero:
dove ρi è pari a:
E [twk ] = ³
1−
E [tsrim ]
´³
´
Pk
ρ
1
−
ρ
i
i
i=1
i=1
Pk
ρi = λi E [tsi ] = λ [F (dk ) − F (dk−1 )]
Z
di
di−1
26
ts f n (ts ) dts = λ
Z
di
di−1
ts f (ts ) dts
Da cui sostituendo si ricava la seguente formula:
E [twk ] = ³
3.2.3
1−λ
R dk
0
λ
E t2s
2´
³
£ ¤
1−λ
ts f (ts ) dts
Confronto tra PTSP e PASP
R dk−1
0
ts f (ts ) dts
´
Mettendo a confronto la ptsp con la pasp, ci si aspetta un grande miglioramento della prima rispetto
alla seconda. Pertanto è bene avere un denominatore più grande cosı̀ i tempi di attesa sono più piccoli.
Quindi vogliamo dimostrare che E [twk ]P ASP ≥ E [twk ]P T SP .
In generale si nota che i tempi medi di attesa sono più bassi nel caso ptsp se la distribuzione è
monotona decrescente (ad esempio l’esponenziale), e la distribuzione delle classi è tale che la prima
classe ha un numero di elementi più alto della seconda ma un tempo di servizio inferiore, ovvero gli
intervalli sono equidistanti.
Sappiamo che il numeratore nei due casi è identico, quindi i tempi sono più bassi se il denominatore
è più grande. Quindi dobbiamo dimostrare che:
Ã
1−
k
X
i=1
ρi
!
≥
P T SP
Ã
1−
k
X
ρi
i=1
!
⇒
P ASP
Ã
k
X
ρi
i=1
!
P T SP
≤
Ã k
X
ρi
i=1
!
P ASP
Vediamo com’è fatta la somma dei ρi :
h
X
i=1
ρi =
h
X
λi E [tsi ]
i=1
Quindi è una somma di prodotti di due serie, quella dei λi e quella dei E [tsi ].
Si nota che se una delle due serie è decrescente e l’altra è crescente allora il prodotto delle due somme
è bassa. Ovvero, si ottiene la somma minima quando le due serie sono ordinate, una in ordine decrescente
(λi ) ed una in ordine crescente. Ciò accade nel caso ptsp, ma non nel caso pasp.
Con la ptsp che abbia una distribuzione di servizio monotona decrescente e una distribuzione degli
intervalli equidistanti, si ottiene che:
λ1 ≥ λ2 ≥ . . . ≥ λh
E [ts1 ] ≤ E [ts2 ] ≤ . . . ≤ E [tsh ]
Nel caso pasp nulla si può dire sull’andamento delle due serie, a meno che la divisione non è uniforme
(λi tutti uguali). L’ordine dei λi può essere casuale, mentre quello che sicuramente sappiamo è che i
tempi E [tsi ] sono uguali quindi sicuramente la somma dei prodotti è non inferiore a quella della ptsp,
non abbiamo il caso ottimo.
Per quanto riguarda il tempo medio globale di attesa E [tw ] dobbiamo accontentarci di una formula
che è la media delle medie:
½
Pr
E [tw ]P T SP = k=1 pk E [twk ]
pk = λλk = F (dk ) − F (dk−1 )
Quindi anche in termini globali la disciplina ptsp va meglio della disciplina pasp.
Per quanto riguarda E [tqk ] abbiamo la semplice relazione:
E [tqk ] = E [twk ] + E [tsk ]
E per quanto riguarda il caso globale dobbiamo sempre accontentarci della media delle medie:
E [tq ]P T SP =
r
X
pk E [tqk ]
k=1
Sul confronto con il tempo medio E [tqk ] non si può dire nulla perché in ptsp ogni classe ha un tempo di
servizio diverso. In generale, quello che si ottiene è che con le classi a priorità alta le cose vanno meglio
usando ptsp anche nel caso di E [tqk ].
27
In sintesi:
E [twk ]P ASP ≥ E [twk ]P T SP
E [tw ]P ASP ≥ E [tw ]P T SP
E [tq ]P ASP ≥ E [tq ]P T SP
Esempio
Sia dato un impianto mono processore con tempo di servizio esponenziale di media pari a E [ts ] = 0.4 sec
e soggetto ad un flusso di richieste di tipo poissoniano. Si vuole studiare l’effetto dell’introduzione di una
disciplina prioritaria basata sul tempo di servizio. La disciplina prevede di avvantaggiare i job “brevi”
rispetto ai job “lunghi”. Più in particolare, il flusso di arrivi viene ripartito in due classi, dando priorità 1
ai job che richiedono un tempo di servizio non superiore alla media. Tutti gli altri job saranno di classe 2.
Si studi l’effetto sul tempo medio di attesa al crescere della frequenza media di arrivo λ = 1, 1.5, 2job/sec.
L’impianto viene modellato come nella seguente figura:
Bisogna trovare gli intervalli temporali per le due classi: d0 = 0, d1 = 0.4 e d2 = ∞. I job di classe 1 sono
quelli in cui il tempo di servizio appartiene all’intervallo (d0 , d1 ], mentre i job di classe 2 hanno tempo
di servizio nell’intervallo (d1 , d2 ).
Calcoliamo i tempi medi di servizio delle due priorità secondo la distribuzione esponenziale:
1
E [tsk ] =
F (dk ) − F (dk−1 )
dk
1
µ
tf (t) dt = −µdk−1
− e−µdk
e
dk−1
Z
Z
dk
d
−µt
te
dt =
dk−1
[−e−µt (µt + 1)]dkk−1
e−µdk−1 − e−µdk
Quindi per la classe 1 otteniamo:
E [ts1 ] =
0.4 − 0.8e−1
= 0.1672 sec
1 − e−1
mentre per la classe 2:
E [ts2 ] =
0.8e−1
= 0.8 sec
e−1
A questo punto troviamo i vari ρk :
ρk = λk E [tsk ] = λ [F (dk ) − F (dk−1 )] E [tsk ]
Ovvero:
½
¡
¢
ρ1 = λ 0.4 − 0.8e−1
ρ2 = 0.8λe−1
In questo modo siamo in grado di calcolarci i tempi medi di attesa delle due classi di priorità:

ρE[ts ]
0.16λ

 E [tw1 ] = 1−ρ1 = 1−0.1057λ
0.16λ
s]
E [tw2 ] = (1−ρ1ρE[t
−ρ2 )(1−ρ1 ) = (1−0.1057λ)(1−0.4λ)


E [tw ] = [F (0.4) − F (0)] E [tw1 ] + [F (∞) − F (0.4)] E [tw2 ]
La seguente tabella fa vedere i risultati in base ai λ proposti nell’esercizio:
λ
1
1.5
2
E [tw1 ]
0.1789
0.2852
0.4058
E [tw2 ]
0.2982
0.7131
2.0289
E [tw ]2P T SP
0.2228
0.4426
1.0029
28
E [tw ]F IF O
0.26̄
0.6
1.6
Nel caso dell’heavy tailed, potrebbe succedere che la somma dei ρi di alcune classi è molto più piccola
del ρ globale. Sappiamo che:
E [tw ]P T SP = E [E [twk ]] =
r
X
pk E [twk ]
k=1
Relativamente all’attesa globale, facciamo la stessa considerazione di prima, ovvero se si scelgono intervalli equidistanti si ottiene un’attesa di classe minima e la media minima.
Per quanto riguarda il tempo di risposta individuale, per le classi più grandi non è detto che ciò migliori.
Mentre per il tempo di risposta globale otteniamo che E [tq ]P T SP ≤ E [tq ]P ASP .
In generale, con la ptsp, abbiamo tolto l’astrazione nel momento in cui si formano le classi, ma le code
rimangono di tipo fifo. Pertanto all’interno della singola classe, si ottiene ancora uno scheduling di tipo
astratto e quindi i job lunghi possono far attendere i job brevi.
3.2.4
Shortest Processing Time First (SPTF)
In questo paragrafo vediamo com’è possibile migliorare ulteriormente ptsp. La ptsp non ha un ordinamento basato sul tempo all’interno delle singole code. Quindi se ho un job a ed un job b che arriva
dopo a, anche se tsa > tsb in ogni caso il job a verrà servito per prima. Si può migliorare la disciplina
portando all’infinito il numero delle classi, ordinando i job rispetto al loro tempo di servizio. Ovvero
come se si usassero code di lunghezza 1 al limite per r → ∞. Quindi ogni volta che il servente si libera
viene servito per primo il job che richiede il tempo minimo di servizio.
In formule si nota che:
r
E [tw ]P T SP =
Portando r → ∞ si ottiene:
F (dk ) − F (dk−1 )
λ £ 2¤ X
³
´³
´
E ts
R dk
Rd
2
1 − λ 0 k−1 ts f (ts ) dts
k=1 1 − λ 0 ts f (ts ) dts
E [tw ]SP T F = lim E [tw ]P T SP
r→∞
Si ricorda che f (ts ) =
dF (ts )
dts
λ £ ¤
= E t2s
2
e pertanto si dimostra che:
29
Z
0
∞
h
dF (ts )
i2
Rt
1 − λ 0 s tdF (t)
·
tw
E
tq
¸
SP T F
·
tw
≤E
tq
¸
P T SP
·
tw
≤E
tq
¸
P ASP
Fra le discipline a priorità senza prelazione, la sptf è la migliore in termini di tempo medio di attesa.
Tale miglioramento è ottenuto grazie all’eliminazione della politica fifo interna a ciascun livello della
ptsp.
3.3
Discipline con prelazione
Supponiamo che in un centro ci sia in esecuzione il job Uk′ . Arriva un job Uk con k < k ′ . Dato che la
priorità è maggiore, ovvero il numero k minore, ha il diritto di interrompere Uk′ ed ottenere il servente.
La prelazione può avvenire in due modi:
1. con perdita: nel caso in cui il servizio riparte dall’inizio, come se fosse un nuovo job in arrivo (λ
cresce).
2. senza perdita: nel caso in cui è possibile salvare lo stato del job e riprendere il servizio dal punto
in cui era stato interrotto.
Da questo momento in poi si parlerà solo di prelazione senza perdita.
Ad esempio, la prelazione si usa nella atm per gestire la priorità dei flussi di pacchetti.
3.3.1
Disciplina a priorità astratta con prelazione (PACP)
L’utente di classe k deve comunque attendere gli utenti delle classi precedenti che arrivano o che erano
già presenti nel sistema. Quindi in questo tipo di politica bisogna prendere il flusso di arrivo delle prime
k classi. In altre parole, il tempo medio di attesa ha tre componenti:
1. Il tempo medio per completare il servizio corrente non interrompibile (dunque di classe 1, . . . , k).
2. Il tempo medio per servire i job già presenti nelle code da 1 a k.
3. Il tempo medio per servire i job arrivati nelle code da 1 a k − 1 durante il periodo di attesa.
Le componenti dei punti 2 e 3 corrispondono al primo ed al secondo fattore del denominatore della
seguente formula:
£ ¤ Pk
1
λi
E t2s
2
´
´ ³ i=1P
E [twk ] = ³
Pk
k−1
1 − i=1 ρi 1 − i=1 ρi
Tale tempo di attesa tiene conto del tempo che il job deve attendere tra quando arriva e quando ottiene per
la prima volta (ovvero non viene preso in considerazione il caso in cui viene interrotto e successivamente
ripreso) il servizio.
Il numeratore, questa volta, rappresenta il tempo di servizio rimanente del job in servizio solo se
ha diritto di rimanere. Quindi nel numeratore non si può mettere tutto λ, ma dobbiamo tenere in
considerazione quella parte di λ che non sarà interrompibile da parte di Uk (ovvero per le prime k classi).
Essendo il numeratore più piccolo del caso pasp allora:
E [twk ]P ACP ≤ E [twk ]P ASP
Dal punto di vista del tq , il tempo ulteriore che un job potrebbe attendere per effetto della prelazione
viene inserito nel calcolo di ts . Infatti il tempo di servizio dei job può crescere visto che possono essere
interrotti. Pertanto l’attesa ulteriore viene considerata andando a calcolare il tempo di servizio medio
virtuale, che tiene conto di E [ts ] e dell’allungamento del tempo di servizio in virtù della prelazione.
Questo tempo cresce in proporzione dei ρk , poiché ρk dice qual’è la probabilità che arrivino i job della
classe k:
i
h
E [ts ]
E tskvirt =
Pk−1
1 − i=1 ρi
Il tempo di servizio virtuale è maggiore del tempo di servizio della pasp.
30
Quindi è vero che diminuisce il tempo di attesa ma cresce il tempo di servizio al crescere dell’indice
della classe. Per questo motivo, dal punto di vista del tqk non si può fare nessun confronto con la pasp
essendo:
i
h
E [tqk ] = E [twk ] + E tskvirt
Per quanto riguarda gli indici globali, la media del tw si ottiene tramite una somma pesata, mentre per
il tq si usa il tempo di servizio virtuale, ovvero:
E [tw ] =
r
X
pk E [twk ]
k=1
E [tq ] =
r
X
pk E [tqk ] = E [tw ] +
r
X
k=1
k=1
i
h
pk E tskvirt
Confrontando i tempi globali possiamo invece affermare che la disciplina pacp va meglio della pasp.
3.3.2
Disciplina a priorità non astratta con prelazione (PTCP)
Considerando i tempi di servizio, se abbiamo due classi h e k con h < k allora otteniamo che E [tsh ] <
E [tsk ]. Nel caso della prelazione abbiamo due casi da distinguere:
1. Prelazione semplice: se in servizio c’è un job Uk′ e arriva un job Uk con k ′ > k allora Uk′ viene
interrotto e prende servizio Uk .
2. Semi-prelazione: piuttosto che valutare la classe di priorità è più saggio valutare il tempo di servizio
rimanente di Uk′ .
Infatti se il job aveva già svolto quasi tutto il suo lavoro non ha senso farlo attendere.
Quindi se il tempo rimanente di Uk′ è maggiore del tempo di servizio di Uk allora viene tolto dal servizio
altrimenti rimane. In altre parole, l’interruzione avviene soltanto se la richiesta del nuovo job è minore
del tempo di servizio rimanente del job attualmente servito (cambia la priorità). Ovviamente i job della
stessa classe non vengono interrotti.
Come abbiamo visto con la ptsp, le classi si formano nel seguente modo:
• Divido il tempo di servizio ts ∈ [0, D] nel seguente modo:
0 = d0 < d1 < . . . < dr = D
• Un job U è di classe k se cade nell’intervallo (dk−1 , dk ].
• Per ogni classe la disciplina di servizio è fifo.
Quindi otteniamo:
E [tsk ] =
Z
dk
ts f n (ts ) dts
dk−1
hR
i
(ts ) + (1 − F (dk )) d2k
´³
´
E [twk ] = ³
Rd
Rd
1 − λ 0 k ts f (ts ) dts 1 − λ 0 k−1 ts f (ts ) dts
λ
2
dk 2
ts dF
0
Al numeratore abbiamo due termini:
Rd
1. λ2 0 k t2s dF (ts ): rappresenta il tempo di servizio rimanente dei job che non sono interrompibili,
ovvero se arriva Uk tutti quelli che hanno priorità maggiore, ovvero i job di classe da 1 a k).
¡
¢
2. λ2 (1 − F (dk )) d2k : rappresenta il contributo del tempo di servizio rimanente di quei job che pur
essendo interrompibili, ovvero i job di classe dalla k + 1 a r, hanno tempo rimanente tale da poter
riprendere il servizio subito (semi-prelazione).
Si nota che 1 − F (dk ) è la probabilità di essere nella classe che va dalla k + 1 ad r (ovvero la
probabilità di essere un job interrompibile), infatti:
P (ts > dk ) = 1 − P (ts ≤ dk ) = 1 − F (dk )
31
Per le considerazioni analoghe al caso senza prelazione, la ptcp va meglio della pacp. Per quanto
riguarda i tempi globali:
hR
i
dk 2
2
r [F (d ) − F (d
r
)]
t
dF
(t
)
+
(1
−
F
(d
))
d
X
X
k
k−1
s
k
s
k
0
λ
´
´³
³
pk E [twk ] =
E [tw ] =
R dk−1
R dk
2
1−λ
t f (t ) dt
1−λ
t f (t ) dt
k=1
Inoltre:
k=1
0
 h
i

 E tskvirt =
s
s
E [tsk ]
Pk−1
1−
i=1
s
0
s
s
s
ρi
E [tqk ] = E [twk ] + E [tsk ]


E [tq ] = E [tw ] + E [ts ]
I tempi globali nel caso della ptcp sono migliori nel caso pacp astratta e ptcp con prelazione semplice:
¸
¸
¸
·
·
·
twk
twk
twk
E
≤E
≤E
tw P T CPsemi−prel
tw P T CP
tw P ACP
Confrontandola invece con la sptf non è possibile stabilire a priori quale delle due sia migliore, ciò
dipende dalla varianza e dal numero di classi. Ovvero non possiamo sapere quale fenomeno pesa di più,
se l’astrattezza delle code fifo o la prelazione. Il caso ottimo consiste nell’introdurre la prelazione nella
sptf.
3.3.3
Shortest Remaining Processing Time First (SRPTF)
Come abbiamo fatto nel caso delle discipline senza prelazione, anche in questo caso per migliorare
ulteriormente la ptcp semi-prelazionata si prova ad aumentare il numero di classi. Nella srptf non ci
sono più delle classi ma i job vengono ordinati in base a quello che chiedono, inoltre viene aggiunta la
semi-prelazione. Ovvero appena il job arriva viene collocato esattamente nella posizione corretta e non
rispetto alla media, quindi viene anche valutato il tempo rimanente del job in servizio introducendo la
prelazione. Dato che esistono infinite classi di priorità quindi facendo il limite per r → ∞ si ottiene:
i
hR
ts 2
2
Z
λ ∞ 0 ts dF (ts ) + (1 − F (dk )) dk
E [tw ] =
dF (ts )
´2
³
Rt
2 0
1 − λ 0 s ts dF (ts )
Per confrontare la srptf con la fb si valuta il ts chiesto e l’anzianità del job. Secondo la srptf, a mano
a mano che il tempo passa il job sale di priorità, mentre la fb fa esattamente il contrario, ovvero amano
a mano che l’anzianità cresce scende di priorità.
SRP T F
FB
È stato dimostrato che E [tq (k)]
≤ E [tq (k)] . Pertanto la srptf è un pò l’ottimo ed infatti è
stato proposto sopratutto nei web server con job interrompibili e traffico heavy tailed.
3.3.4
Confronti tra discipline
A questo punto facciamo un piccolo riassunto di ciò che è stato detto in precedenza.
Nel caso a priorità a tempo, si ha la serie ordinata minima cosı̀ da ottenere un E [tw ] minore.
Il tempo di servizio medio della prima classe è minimo, mentre per le altre classi cresce. Vale il contrario
per i λi .
La ptcp semi-prelazionata si comporta meglio della pacp.
Per il tempo di attesa in coda, invece, bisogna anche considerare il tempo di servizio virtuale.
È facile convincersi che valgono le seguenti relazioni:
E [tw ]SRP T F ≤ E [tw ]SP T F ≤ E [tw ]P T CPsemi−prel ≤ E [tw ]P ST P ≤ E [tw ]P ASP ≤ E [tw ]KP
32
tw
P T SP ≤ P ASP
SP T F ≤ P T SP
P ACP ≤ P ASP
P T CPsemi−prel ≤ P ACP
P T CPsemi−prel ≤ P T SP
SRP T F ≤ P T CPsemi−prel
SRP T F ≤ SP T F
P T CPsemi−prel ≤ SP T F
tq
P T SP ≤ P ASP (g/l)
SP T F ≤ P T SP (g)
Non si può dire
Non si può dire
Non si può dire
Non si può dire
Non si può dire
Non si può dire
Senza prelazione
Introduco la prelazione
Con prelazione
Dipende
Dalla precedente tabella, rimane fuori il confronto della ptcp semi-prelazionata con la sptf. Infatti
la componente astratta potrebbe essere più pesante o ci potrebbe essere una lunga attesa rispetto al
servizio rimanente e ciò incide molto se non c’è prelazione.
Esempio
Sia un centro a legge esponenziale con E [ts ] = 1, λ = 0.8, trovare il punto di ottimo per ognuna delle
discipline:
Disciplina
FIFO
2/PASP
E [tq ]
5
5
2/PTSP
SPTF
2/P T CPsemi−prel
3.3
2.9
2.8
SRPTF
2.3
Come se le classi non ci
fossero proprio dal punto
di vista dei tempi globali
Risulta essere migliore
della SPTF
Va specificato come siano formate le due classi. Caso per caso è stato scelto il punto di ottimo. Non è
detto, naturalmente, che i punti di ottimo siano gli stessi per tutte le discipline.
3.3.5
Confronto tra PTSP e PASP
Riprendiamo le formule relative alla ptsp:
½
Pr
E [tw ]P T SP = E [E [twk ]] = i=1 pi E [twi ]
pk = λλk = F (dk ) − F (dk−1 )
dalle quali otteniamo:
r
E [tw ]P T SP =
λ £ 2¤ X
F (dk ) − F (dk−1 )
³
´³
´
E ts
R
Rd
d
k
2
1 − λ 0 k−1 ts dF (ts )
k=1 1 − λ 0 ts dF (ts )
In qualsiasi disciplina prioritaria, la prima classe è favorita. L’indice globale è minore del caso pasp dato
che nella ptsp la serie di pi è decrescente, quindi:
E [tw ]P T SP ≤ E [tw ]P ASP
Dato che E [tq ]P T SP è pari a:
E [tq ]P T SP = E [E [tqk ]] =
r
X
k=1
pk E [tqk ] =
r
X
pk (E [twk ] + E [tsk ]) = E [tw ]P T SP +E [ts ]P T SP
k=1
33
allora il confronto si limita al E [tw ] perché E [ts ]P ASP = E [ts ]P T SP , ovvero:
E [tq ]P T SP ≤ E [tq ]P ASP
3.3.6
Confronto tra PACP e PASP
Dal punto di vista globale, E [tq ] e E [tw ] si comportano nello stesso modo con due classi esponenziali
nel caso di disciplina pacp.
h
E [tq ] = p1 E [tq1 ] + p2 E [tq2 ] = p1 [E [tw1 ] + E [ts ]] + p2 E [tw2 ] +
i
h
h
i
1
1
1 +p2 −(1−ρ)
=
= p1 1−ρ
+
p
= p(1−ρ
2
(1−ρ
)(1−ρ)
1
1
1 )(1−ρ)
1
= 1−ρ
E [ts ]
E[ts ]
1−ρ1
i
=
Esempio
Nel caso di una pasp possiamo dire che è migliore di una politica fifo poiché considerando un numero
di classi superiore a 2 abbiamo la seguente relazione:
Ã
1−
k
X
i=1
ρi
!Ã
1−
k−1
X
ρi
i=1
!
>1−
r
X
ρi → E [twk ]P ASP < E [tw ]F IF O
i=1
Nel caso invece che il numero di classi è pari a 2 abbiamo:
2
λ
λ
E [t2 ]
2 E [ts ]
E [tw ]P ASP = p1 E [tw1 ] + p2 E [tw2 ] = p1 21−ρ1s + p2 (1−ρ
1 )(1−ρ)
³
´
£ ¤ p1
£ ¤ p1 (1−ρ)+p2
2
= λ2 E t2s (1−ρ
+ (1−ρ1p)(1−ρ)
= λ2 E t2s 1−ρ
1
1 )(1−ρ)
£ ¤ p1 −p1 ρ+p2
£ 2¤ 1
λ
=
E
t
= λ2 E t2s (1−ρ
s 1−ρ
2
1 )(1−ρ)
=
=
= E [tw ]F IF O
Mentre in media i tempi di attesa non migliorano.
Esempio
£
¤
Mettiamo a confronto E [twk ]P ASP ≤ E twk+1 :
³
1−
Pk
i=1
λ
t2
2E
´³s
ρi
£ ¤
1−
Pk−1
i=1
1−
ρi
´≤³
k−1
X
Pk+1
1−
ρi ≥ 1 −
i=1
k+1
X
λ
t2
2E
´ ³s
ρi
£ ¤
1−
Pk
i=1
ρi
i=1
i=1
ρk + ρk+1 ≥ 0
Consideriamo una pasp con E [ts ] = 0.5 sec, ρ = 0.6 e λ = 1.2 job/sec.
Caso 1
p1 = 0.1
ρ1 = 0.06
E [tw1 ] = 0.31915
p2 = 0.2
ρ2 = 0.06
E [tw2 ] = 0.36267
34
p3 = 0.8
ρ3 = 0.48
E [tw3 ] = 0.85227
´
Caso 2
p1 = 0.8
ρ1 = 0.48
E [tw1 ] = 0.57692
p2 = 0.1
ρ2 = 0.06
E [tw2 ] = 1.25418
p3 = 0.8
ρ3 = 0.06
E [tw3 ] = 1.63043
E [tw ]F IF O = 0.75
Se nelle prime classi cè poco flusso migliorano 2 classi su 3 rispetto alla fifo. Se il numero di classi è
dispari, dipende da come vengono suddivise le classi rispetto a ρ. Infatti, nel secondo caso vanno peggio
2 classi su 3.
E [tsrim ]
.
Il caso ottimo per suddividere le classi in una fifo è E [tw ] = 1−ρ
3.4
Centro a processori multipli
Un centro può avere più serventi (m) paralleli, quindi al più m job possono essere contemporaneamente
in esecuzione. Tale centro viene detto a processori multipli.
λ
Il flusso λ in arrivo al centro viene ripartito equamente, ovvero λi = m
. Mentre, se i processori sono
uguali tra loro hanno tutti una frequenza di servizio pari a µ. Vediamo come diventano le grandezze
medie:

1

 E [tsi ] = µ
λ
ρ = mµ
λ

 ρ = m
=
i
µ
λ
mµ
Come si può notare ρ del singolo processore è uguale al ρ dell’intero centro. Ma in questo caso non vale
più la relazione ρ = 1 − P (0).
E [tsi ] è il tempo medio che un job impiega una volta che ottiene servizio. Mentre E [ts ] è il tempo
medio che passa da quando un job entra a quando un job (qualsiasi anche non lo stesso) esce. Si nota
che E [ts ] è m volte più piccolo, ovvero:
1
E [ts ] =
mµ
Quindi si ottiene che il tempo globale è:
E [tq ] = E [tw ] + E [tsi ]
Per quantificare il tempo rimanente si deve calcolare il ρ globale ed E [ts ] poiché bisogna avere la
probabilità che uno degli m serventi si liberi. Quindi:
E [q] = E [w] + mρ
Tramite la legge di Little siamo in grado di ricavare le seguenti formule:
(
E [tw ] = E[w]
λ
E [tq ] = E[q]
λ
3.4.1
Caso M/M/m astratto
Nel caso di processori singoli con M/G/1 si usa la KP, al contrario in M/G/m non esiste una forma
chiusa.
A tal proposito esiste una forma chiusa solo per M/M/m, ovvero abbiamo un centro a processori multipli,
distribuzione del tempo di arrivo poissoniana, distribuzione del tempo di servizio esponenziale e disciplina
di tipo astratto.
Se si avesse a disposizione la E [w] si può ricavare tutto il resto. Sia P (q) la probabilità di avere q job
nel centro:
½ 1
q
q! (mρ) p (0) 1 ≤ q ≤ m
m
P (q) =
m
q
q>m
m! ρ p (0)
35
dove p (0) è la probabilità del centro vuoto:
p (0) =
!
"Ãm−1
X (mρ)i
i=0
i!
m
(mρ)
+
m! (1 − ρ)
#−1
Dalla precedente formula possiamo trovare la probabilità di avere tutti i serventi occupati, ovvero di
avere m job in attesa:
∞
m
X
(mρ)
p (0)
p (q) =
B = P (q ≥ m) =
m! (1 − ρ)
q=m
A questo punto per una distribuzione di tipo K-Erlang abbiamo che
E [w]Ek = B
ρ
1−ρ
di conseguenza il tempo di servizio globale è:
E [tw ]Ek =
E [w]Ek
Bρ
BE [ts ]
=
=
λ
λ (1 − ρ)
1−ρ
Il numeratore è l’analogo di ρE [ts ] nel caso M/M/1. Ovvero nel caso del servente singolo rappresenta
la probabilità che il servente sia occupato, mentre nel caso di processori multipli, B rappresenta la
probabilità che gli m siano occupati:
E [tsrim ] = BE [ts ]
In questo caso si nota che B è più piccolo di ρ e di conseguenza tsrim è inferiore in un sistema multiservente.
3.4.2
Numero di serventi occupati
Un’altra grandezza interessante è C definita come il numero istantaneo di serventi occupati, e va da 0 a
m. La sua media è:
∞
m−1
X
X
mp (q) = mρ
qp (q) +
E [c] =
q=m
q=0
Fino ad m la probabilità di avere un servente occupato è come sempre la somma pesata di tutti i valori
che può assumere per la probabilità di assumere tale valore. Da m in poi, qualsiasi sia q il numero di
canali occupati sarà m. La seconda sommatoria và ad infinito poiché stiamo trattando code illimitate.
Ma sappiamo che per definizione il numero di serventi occupati è mρ. Quindi da questa abbiamo il
modo di calcolarci ρ nel servente multiplo:
ρ=
∞
m−1
m−1
X
1 X
1 X
mp (q) =
qp (q) +
qp (q) + B
m q=0
m q=0
q=m
Da cui si vede chiaramente che ρ ≥ B.
Esempio
Dato un impianto a processore singolo con:
• Capacità C = 106 op/sec,
• Domanda media Z = 4 · 105 op/sec,
• ρ = 0.4.
36
1. Determinare E [w] nel caso di disciplina fifo, pacp a due classi (divise in 35% e 65%).
Nel caso di disciplina fifo eseguiamo il seguente calcolo:
E [w]F IF O =
ρ2
= 0.26̄
1−ρ
Mentre nel caso di disciplina pacp a due classi calcoliamo innanzitutto E [ts ] e λ:
E [ts ] =
λ=
Z
= 0.4 sec
C
ρ
= 1 job/sec
E [ts ]
Successivamente troviamo i λi :
½
Di conseguenza troviamo i ρi :
λ1 = 0.35λ = 0.35 job/sec
λ2 = 0.65λ = 0.65 job/sec
½
ρ1 = λ1 E [ts ] = 0.14
ρ2 = λ2 E [ts ] = 0.26
Quindi i job di classe 1 non vedono quelli di classe 2 e trovano il servente occupato per il 14%,
mentre i job di classe 2 attende tutti i job che arrivano e deve attendere anche i job di classe 1 che
arrivano (con prelazione).
(
E[ts ]
E [tw1 ] = ρ11−ρ
= 0.06512 sec
ρ[ts ]
E [tw2 ] = (1−ρ)(1−ρ1 ) = 0.31008 sec
Quindi:
E [w]2P ACP = λE [tw ] = λ (E [tw1 ] ρ1 + E [tw2 ] ρ2 ) = 0.22434
2. Si consideri di sostituire l’impianto con un altro a 2 processori di capacità totale costante. Determinare E [w] nel caso di disciplina pacp a due classi.
In questo caso cambia il tempo medio di servizio:
E [tsi ] =
Z
C
m
= 0.8 sec
A questo punto calcoliamo i ρi :
Calcoliamo i E [twi ]:

λ
E [tsi ] = 0.4
 ρglob = m
ρ1 = λ1 E [ts ] = 0.14

ρ2 = λ2 E [ts ] = 0.26
 (
1 E[ts ]

= 0.01599 sec
E [tw1 ] = B1−ρ

1

h
i


(mρ1 )m
(mρ1 )m

B
=
1
+

1
m!(1−ρ1 )
m!(1−ρ1 ) = 0.03438
 (
BE[ts ]
E [tw2 ] = (1−ρ)(1−ρ1 ) = 0.17718 sec

h
i


(mρ)m
(mρ)m

1
+
mρ
+
B
=


m!(1−ρ)
m!(1−ρ) = 0.22857


m=2
Rispetto al servente singolo c’è un sensibile miglioramento, poiché aggiungendo un servente i job
attandono meno. Dal punto del tq le cose vanno peggio. La scelta della struttura del centro dipende
dalla grandezza che vogliamo ottimizzare.
37
3.5
Effetto della distribuzione di capacità e dei fattori di scala
Vediamo ora, in termini generici, cosa succede quando si distribuisce la capacità di un sistema su più
serventi, ovvero facciamo il confronto tra un sistema a capacità C ed un sistema a capacità C ma divisa
per m serventi. Ci si chiede se conviene e sotto quali punti di vista. In generale, dimostreremo che
conviene rispetto al tempo di attesa (tw ) mentre non conviene rispetto al tempo di permanenza (tq ).
L’uso di questa tecnica dipende quindi da quale indice si vuole ottimizzare.
Un’altro problema tipico consiste in un sistema sottoposto ad un flusso λ. Se questo flusso cresce
(e ne basta poco per avere un degrado degli indici) ad esempio di un fattore a (cioè diventa aλ) allora
quanto bisogna far crescere C per avere le stesse prestazioni?
3.5.1
Problema della distribuzione di capacità
Sia C la capacità globale, mentre
per job:
C
m
la capacità del singolo servente, Z è il numero di operazioni richieste
(
Z
E [ts ] = C
Z
E [tsi ] = Z
C = mC
m=1
m>1
m
Si vede che nel caso del servente multiplo il tempo di servizio del singolo è m volte più lento del servente
singolo in quanto la capacità viene ridotta. Il tempo medio (generale) è il tempo che passa da quando
un job entra a quando il prossimo job (non lo stesso obbligatoriamente) esce. Come noto abbiamo che µ
è:
(
µ = E[t1 s ]
µi = E 1t
[ si ]
Inoltre i ρi sono costituiti dal flusso che arriva (al servente o all’intero sistema) per il tempo di servizio
(del servente o dell’intero sistema) ovvero rispettivamente:
½
ρ = λE [ts ] = Zλ
C
λ
E [tsi ] = Zλ
ρi = m
C
Come si nota sono identici sia nel caso globale che nel caso singolo, ovvero ρi = ρ.
Inoltre per quanto riguarda il tempo di permanenza:
½
E [tq ] = E [tw ]KP + E [ts ] servente singolo
E [tq ] = E [tw ]Ek + E [tsi ] servente multiplo
A questo punto vediamo quale configurazione è migliore per risolvere il problema della distribuzione
della capacità.
Supponiamo di avere tre tipologie tutte a parità di ρ:
Tipo a Divide il flusso λ in m code, dove ognuno ha il suo servente di capacità
(
λ
λtot = m m
=λ
C
m
=C
µtot = E t = m mZ
Z
[ si ]
C
m.
Pertanto otteniamo:
Questa prima configurazione presenta delle evidenti inefficienze. Ci possono essere delle code vuote
e delle code piene, ovvero i serventi non sono tutti utilizzati.
ρ lo vediamo sempre come rapporto tra la frequenza totale degli arrivi e la frequenza totale delle
uscite, quindi:
mλ
Zλ
m
ρ = mC
=
C
mZ
38
Tipo b Miglioriamo la precedente tipologia mettendo tutte le code in un’unica coda, ovvero ρ diventa:
ρ=
λ
m
E [tsi ]
=
Zλ
C
Anche in questo caso abbiamo inefficienze, infatti quando la coda è vuota e alcuni serventi sono
liberi mentre altri risultano inutilizzati.
E [w]Ek
BE [ts ]
BZ
=
=
λ
1−ρ
(1 − ρ) C
·
¸
Z
B
Z
tq (m, λ, C) = Tw (m, λ, C) + m =
+m
C
1−ρ
C
tw (m, λ, C) =
Tipo c Miglioriamo la precedente tipologia concentrando la capacità, ovvero un’unica coda ed un unico
servente:
Zλ
ρ=
C
E [w]KP
ρE [ts ]
Zρ
tw (1, λ, C) =
=
=
λ
1−ρ
(1 − ρ) C
tq (1, λ, C) = Tw (1, λ, C) +
39
Z
Z
=
C
(1 − ρ) C
Per trovare una soluzione a questo primo caso, facciamo il confronto tra la tipologia b e c. Per
quanto riguarda tw vediamo che il confronto del tempo di attesa si basa sul confronto tra B e ρ, cosa
che abbiamo già fatto vedendo che ρ ≥ B. Quindi in generale il tempo di attesa di un servente singolo è
più grande del tempo di attesa del servente multiplo a parità di capacità C.
Per quanto rigurada il tempo di permanenza tq , dobbiamo considerare che nel caso b abbiamo un
termine m che moltiplica mentre il primo termine tw è minore rispetto al caso c. Quindi ci troviamo
nella seguente situazione:
tw (m, λ, C) ≤ tw (1, λ, C)
Z
mZ
≥
C
C
Sperimentalmente si vede che la crescita di tw è sub-lineare, quindi vince la crescita di E [ts ] che è lineare
per m. Sommando, ovvero calcolando tq , abbiamo una crescita, inferiore a E (ts ) ma sempre una crescita.
In conclusione, il tempo di permanenza è inferiore nel caso del servente singolo, contrariamente a
quanto avveniva con il tempo di attesa.
3.5.2
Problema del fattore di scala
Introduciamo due ulteriori tipologie (sempre con ρ uguale per tutti):
Tipo d Dal punto di vista strutturale è identico alla tipologia b, ma si ha una percentuale di arrivi λ e
capacità del singolo servente (C/m) aumentati di un fattore a.
(
Z
= mZ
E [tsi ] = aC
aC
m
ρ = aλE [tsi ] =
Zλ
C
E [w]Ek
Bρ
BE [ts ]
BZ
=
=
=
aλ
(1 − ρ) aλ
1−ρ
(1 − ρ) aC
·
¸
B
Z
tw (m, λ, C)
=
+m
tq (m, aλ, aC) =
a
1−ρ
aC
tw (m, aλ, aC) =
W (m, λ, C) = λtw (m, λ, C) = aλtw (m, aλ, aC) = W (m, aλ, aC)
Q (m, λ, C) = λtq (m, λ, C) = aλtq (m, aλ, aC) = Q (m, aλ, aC)
Tipo e Questa è una variante della tipologia c, dove sia la frequenza degli arrivi che la capacità del
singolo centro viene aumentata di un fattore di scala a.
tw (1, aλ, aC) =
E [w]KP
ρE [ts ]
Zρ
tw (1, λ, C)
=
=
=
aλ
1−ρ
(1 − ρ) aC
a
tq (1, λ, C) =
Z
tq (1, λ, C)
=
a
(1 − ρ) aC
40
Mettendo a confronto le tipologie b e d e le tipologie c ed e si ottiene che amumentando dello stesso
fattore di scala il flusso e la capacità diminuisce il tempo di attesa ed il tempo di permanenza dello stesso
fattore a. Questa cosa vale anche per distribuzioni non esponenziali. Inoltre si vede che le popolazioni
medie rimangono uguali.
È importante notare che se si aumenta solo λ allora si ottiene comunque un peggioramento del
comportamento dell’intero sistema nel caso d, mentre nel caso e è sufficiente aumentare di poco la
capacità per ottenere le stesse prestazioni.
41
4
Modelli a reti di code
I modelli a reti di code si dividono in:
• aperti : i job arrivano, entrano nel sistema ed escono. Non c’è popolazione fissa.
• chiusi : Non ci sono ingressi ed uscite ma solo una popolazione fissa che si sposta.
• misti : Esistono classi di job (modelli multiclasse). Per alcune classi il modello è chiuso, per altre
il modello è aperto.
Supponiamo di avere un flusso λ nel centro C1 e poi di avere un altro centro C2 in cascata a questo.
Gli arrivi sono regolati tramite legge di Poisson e i servizi sono di tipo esponenziale. Se il centro C1 ed
il centro C2 sono del tipo M/M/1 allora applichiamo le soluzioni note. Il centro C2 è indipendente dal
centro C1 ed è quindi possibile analizzarlo una volta isolato. Osserviamo che per condizioni stazionarie
il tasso di uscita di C1 sarà pari a λ.
Qui di seguito analizzeremo i modelli a rete di code di tipo Markoviano.
Tale modello deve soddisfare due proprietà:
1. Si possono rappresentare le possibili condizioni della rete con un insieme di stati Si che sono:
(a) Mutuamente esclusivi: se prendiamo una coppia di stati qualsiasi della rete si devono escludere
l’un l’altra, non ci possono essere condizioni in cui la rete si trova in parte in uno stato e in
parte in un altro. Quindi le condizioni si devono escludere.
(b) Collettivamente esaustivi: questo insieme (anche illimitato) deve coprire tutte le condizioni
della rete.
Tale modello deve coprire tutti i possibili stati ammissibili nella rete.
2. Si può ritenere che la scelta dello stato futuro sia dipendente solo dallo stato corrente e non da
quelli precedentemente visitati.
Processo Stocastico È rappresentato da un insieme di variabili aleatorie con indice il parametro di
tempo t: {X (t1 ) , X (t2 ) , X (t3 ) , . . .}.
Spazio degli stati di un processo È l’insieme dei possibili valori assunti da X (t). Possono essere
un numero limitato o illimitato di valori. Se lo spazio è finito, quindi numerabile, siamo nel caso di un
processo a stati discreti e si usa il termine di catena stocastica al posto di processo. Inoltre dobbiamo
tenere conto che il tempo può essere continuo o discreto. Nel caso di tempo continuo si parla di catena
a tempo continuo.
Catena di Markov Vediamo ora la definizione formale in cui si evince la proprietà 1:
P {X (tn+1 ) = xn+1 |X (tn ) = xn | . . . |X (t1 ) = x1 } = P {X (tn+1 ) = xn+1 |X (tn ) = xn }
La catena di Markov è importante perché quando parleremo di modelli, reti di code, ecc... sottostante a
questi c’è una catena di Markov, la cui soluzione porterà alla soluzione del modello. Resta comunque più
semplice definire il modello che è a sua volta più vicino al sistema che definire direttamente la catena.
Stato della rete Quando parliamo della rete definiamo lo stato della rete come (n1 , . . . , nm ), dove m
è il numero dei centri ed ni indica quanti job ci sono nel centro Ci . Questo di fatto è lo stato del processo
markoviano sottostante alla rete, da cui ricaveremo la soluzione.
42
Modello Markoviano
Spazio degli stati della rete
a:
Sia (n1 , n2 , . . . , nM ) lo stato della rete, allora lo spazio degli stati è pari
E=
(
(n1 , . . . , nM ) |0 ≤ ni ≤ N,
M
X
ni = N
i=1
)
La sommatoria è necessaria perché stiamo parlando di una rete chiusa.
Per generare gli stati di un sistema di solito si usa l’algoritmo lessicografico inverso, il quale consiste nei
seguenti passi:
• Si parte mettendo tutti gli N job nel primo centro,
• Si toglie un job dal primo centro e lo sposto sul secondo, poi sul terzo, ecc...
• Si toglie un altro job sempre dal primo centro e lo sposto sul secondo, poi sul terzo, ecc...
¡ +M −1¢ (N +M −1)!
= (M −1)!N ! .
Di conseguenza la cardinalità di questo insieme è pari a: |E| = NM
−1
Tempo di vita in uno stato Ad ogni stato è associabile un tempo di vita tvi ed essendo una variabile
aleatoria avrà una media definita come: E [tvi ] = a1i , dove ai è il tasso di uscita dallo stato Si (il tempo
è sempre l’inverso della frequenza). Nel centro si ha E [ts ] = µ1 . Il tempo di vita del processo di Markov
è una variabile di tipo esponenziale.
Condizione sufficiente ma non necessaria affinché i tempi di vita degli stati siano esponenziali è che i
tempi di servizio dei job nei centri siano esponenziali1 .
Probabilità di transizione tra stati La definiamo con rij ≥ 0 ed indica la probabilità di transizione
dallo stato Si allo stato Sj in un solo passo. In un numero di passi abbastanza grande la probabilità è
sempre 1 in quanto stiamo parlando di un processo irriducibile in cui qualunque stato è raggiungibile da
qualunque altro.
È una probabilità istantanea all’interno del tempo di vita, ovvero si assume di stare in uno stato Si e si
vuole sapere qual’è la probabilità di andare allo stato Sj . Inoltre si considera che due eventi simultanei
hanno una probabilità trascurabile.
Frequenza di transizione da Si a Sj
È per definizione: qij = ai rij .
Esempio
***********INSERIRE IMMAGINE*********
Notazione:
M numero di centri
N numero di job
µi tassi dei centri esponenziali
I centri sono connessi in un certo modo e i job viaggiano secondo una “matrice di routing”. La scelta
del centro da visitare viene fatta su base probabilistica, quindi parliamo di “routing probabilistico indipendente dallo stato”, ovvero indipendente dall’istante di tempo e dallo stato della rete in quell’istante
di tempo. Esistono comunque reti in cui la scelta dipende dalle condizioni di carico dei centri.
Sia data una rete a 3 centri chiusa con M = 3 e N = 2 e la seguente matrice di routing indicata in
generale con P = ||pij ||:

1 Per
0.2
P = 1
1
0.4
0
0

0.4
0 
0
calcolare il tempo di vita basta guardare quali centri non sono vuoti e scrivere
43
P1
i ai
.
La condizione della rete ci indica la posizione dei job nella rete. Ad esempio con la tripla (1, 1, 0) si ha
un job al centro C1 , un job al centro C2 e nessun job nel centro C3 .
Lo spazio degli stati è il seguente:
E = {(2, 0, 0) , (1, 1, 0) , (1, 0, 1) , (0, 2, 0) , (0, 1, 1) , (0, 0, 2)}
Abbiamo 6 stati e come possiamo vedere coprono tutte le situazioni possibili e si escludono l’un l’altro.
Tutti gli stati sono raggiungibili da uno stato qualunque in un numero finito di passi. Ma non è detto
che presa una coppia di stati sia raggiungibile sempre con un passo.
Per calcolare il tempo di vita vediamo quanto dura, ovvero da quali è determinato il suo inizio e la sua
fine. Ad esempio lo stato S1 può essere generato per un arrivo dagli stati {(1, 1, 0) , (1, 0, 1) , (2, 0, 0)}.
Dato che la probabilità di avere due arrivi contemporaneamente è trascurabile allora non consideriamo
tale situazione. Quando si esce dallo stato S1 bisogna spostare un job dal centro C1 , ovvero che il centro
C1 ha terminato un job. La media del tempo di vita di S1 è il tempo medio di servizio del job nello stato
S1 , quindi si sfrutta il fatto di avere distribuzioni esponenziali: E [tv1 ] = µ11 .
Prendiamo lo stato S2 = (1, 1, 0). Entro nello stato S2 se ho un job al centro C1 ed un arrivo nel centro C2
oppure se ho un job nel centro C2 ed un arrivo al centro C1 , come ad esempio da (2, 0, 0) , (0, 1, 1) , (0, 2, 0).
1
Quindi esco dallo stato S1 appena finisce un job nel centro C1 o C2 : E [tv2 ] = µ1 +µ
. Quindi bisogna
2
guardare quali centri non sono vuoti e scrivere 1 diviso la somma dei tassi di uscita.
Calcolare le probabilità di transizione tra stati consiste nel trovare ad esempio la probabilità di andare
dallo stato S2 allo stato S1 , ovvero calcolare r21 . In formule:
r21 = P (termino in S1 , sono in S2 ) = P (termino in S1 |sono in S2 ) P (termino in S1 ) =
µ2
µ2
µ2
µ1 +µ2 p21 = a2 p21 = 1/E [tv ] p21 = E [tv2 ] µ2 p21
2
Ottenendo quindi una frequenza di transizione pari a: q21 = a2 r21 = µ2 p21 . In questo caso, gli indici
coincidono.
Mentre nel caso in cui il job si sposta da S2 a S4 otteniamo: q24 = a2 r24 = µ1 p12 .
Ricordiamo che gli indici di p rappresentano i job che si muovono tra i centri, mentre gli indici di q ed r
rappresentano il collegamento tra gli gli stati.
½










(2, 0, 0)
(1, 1, 0)
(1, 0, 1)
(0, 2, 0)
(0, 1, 1)
(0, 0, 2)
π̄ = π̄Q
π
(S
)= 1
i
∀Si ∈E
P
(2, 0, 0)
(1, 1, 0)
1 − µ1 (p12 + p13 ) µ1 pP
12
µ2 p21
1−
µ3 p31
0
0
µ2 p21
0
µ3
0
0
(1, 0, 1)
µ1 p13
0P
1−
0
µ2
µ3
(0, 2, 0)
0
µ1 p12
0P
1−
0
0
(0, 1, 1)
0
µ1 p13
µ1 p12
0P
1−
0
(0, 0, 2)
0
0
µ1 p13
0
0
1 − µ3
Ad esempio l’equazione per lo stato S2 è cosı̀ impostata:










π (S2 ) = µ2 p21 π (S1 ) + [1 − µ2 p21 + µ1 (p12 + p13 )] π (S2 ) +
µ1 p12 π (S4 ) + µ1 p13 π (S5 )
Da cui, postando a primo membro il termine π (S2 ) si ottiene:
π (S2 ) =
π (S1 ) µ2 p21 + µ1 p12 π (S4 ) + µ1 p13 π (S5 )
µ2 pi21 + µ1 (p12 + p13 )
Questo rappresenta il rapporto tra il flusso di ingresso e quello di uscita.
I due stati S2 ed S3 sono equiprobabili, dato che le due probabilità di routing sono uguali. Anche lo
stato (0, 1, 1) ha la stessa probabilità dello stato (0, 0, 2), ma è un caso particolare.
44
4.1
Soluzione Markoviana
In generale non modelliamo solo sistemi di natura informatica, possiamo applicare le reti di code a molti
sistemi come ad esempio processi aziendali, ecc...
Ovvero questo non è l’unico modello, abbiamo anche le Reti di Petri o le Algebre di processo. Ma siamo
interessati alle reti di code e processi di Markov.
Dall’esponenzialità sui centri dipende l’esponenzialità sugli stati, questa è una condizione sul processo di
Markov.
Ricordiamo le ipotesi in cui siamo:
• Stati della rete mutuamente esclusivi e collettivamente esaustivi.
• Lo stato futuro del processo dipende solo dalla condizione attuale e non dalla storia (memoryless):
– Condizione sufficiente affinché sia vera è che i tempi di servizio dei centri siano distribuiti
esponenzialmente, ovvero i tempi di vita dello stato sono esponenziali.
– Se i centri non sono esponenziali la metodologia può essere applicata lo stesso ma i risultati
saranno approssimati.
– Quindi tvi è una variabile esponenziale.
Definiamo la probabilità di essere nello stato Si nell’istante t come π (Si , t).
Nel caso in cui abbiamo le seguenti condizioni:
• Uno spazio finito (sempre vero con una rete chiusa).
• Il processo sia irriducibile, ovvero ogni stato è raggiungibile da qualcunque altro stato in un numero
finito di passi.
Dato che le reti di cui parliamo sono chiuse allora la condizione è soddisfatta.
Se ci ritroviamo in una rete non irriducibile, se un nodo non è connesso agli altri, dopo un certo
tempo tutti i job si trovano in quel centro, detto centro assorbente.
• Vale l’ergodicità.
Allora il processo dopo un certo tempo raggiunge una condizione di equilibrio, quindi le probabilità
instantanee tendono ad una probabilità che è costante nel tempo, ovvero esiste il seguente limite:
∃ lim π (Si , t) = π (Si )
t→∞
45
La precedente formula indica che il processo tende ad una posizione di equilibrio indipendentemente
dallo stato iniziale, infatti π (Si ) è detta probabilità stazionaria. Più in generale, dato uno stato, bisogna
cercare per ogni centro, quale di questi non è vuoto e vedere da quale centro proviene il job dal centro
originario.
Se il sistema raggiunge l’equilibrio questo vuol dire che il flusso in uscita dallo stato uguaglia il flusso
in ingresso allo stato. Ovvero è valida l’equazione del bilanciamento globale, ossia possiamo scrivere
un’equazione per ogni stato in cui viene eguagliato il flusso di uscita con quello in ingresso.
Quindi dato che il numero degli stati è |E| = Ns avremo un sistema di Ns equazioni in Ns incognite. Tale
sistema è linearmente dipendente va aggiunta una condizione per trovare una soluzione unica, ovvero si
aggiunge la condizione di normalizzazione:
½ P
∀Si ∈E
π (Si ) = 1
π̄ = π̄Q
P
dove Q = ||qij || è la matrice generatrice del processo e qij = 1 − i6=j qij è la diagonale principale.
Il vettore riga risultante π̄ = [π (S1 ) , π (S2 ) , . . . , π (SNs )] è il vettore probabilità di stato. Quindi tramite
i seguenti passaggi:
½
π̄ = π̄Q ⇒ π̄Q − π̄ = 0 ⇒ π̄ (Q − I) = 0
π̄S = 0
dove S è la matrice Q senza 1 sulla diagonale principale, otteniamo che:
½
Esempio
π̄S = 0
P
∀Si ∈E
π (Si ) = 1
Sia µ1 = 4 e µ2 = µ3 = 2 calcolare la soluzione della rete. Per fare ciò troviamo:
0.186
0.182
0.118
0.146
0.227
0.141
π (S1 )
π (S2 )
π (S3 )
π (S4 )
π (S5 )
π (S6 )
Si nota che lo stato S5 è quello con maggiore probabilità che il centro C1 sia vuoto. Infatti il tasso di
uscita è il doppio degli altri. Ma di stati con centro C1 vuoto ce ne sono molti, perché proprio questo?
Perché per il routing c’è equi-probabilità di andare in C2 o in C3 .
4.1.1
Calcolo degli indici
Sia una rete chiusa di legge esponenziale a servente singolo con π (n1 , n2 , . . . , nM ). Una volta ottenuta
la soluzione π = (π (S1 ) , π (S2 ) , . . . , π (SN )), questa viene usata per predire gli indici di prestazione
dell’impianto, ossia il throughput, popolazioni attese, tempi di risposta locali e globali.
Una prima grandezza che dobbiamo calcolarci è la distribuzione di probabilità marginale del singolo
centro, cioè la probabilità che nel centro i ci siano n job:
pi (n) =
X
S̄:ni =n
¡ ¢
π S̄
ovvero la somma delle probabilità di tutti gli stati che presentano n job nel centro Ci .
Da questa possiamo facilmente calcolare la popolazione media del centro Ci :
46
Bilanciamento
Globale
E (ni ) =
N
X
ni pi (ni )
ni =0
dove N è il numero di job della rete.
Per l’utilizzazione del centro Ci , ovvero la percentuale di tempo in cui il centro risulta occupato, va
tenuto conto che λ non è più un parametro di input ma va calcolato in quanto dipende dagli altri centri.
Quindi:
Ui = 1 − pi (0)
dove pi (0) è la probabilità che il centro non sia vuoto, ovvero usiamo la probabilità marginale. In altre
parole, un sistema con nodi a capacità infinita è uguale alla probabilità che il centro non sia vuoto.
Il throughput del centro, ovvero il numero medio di job che lasciano il centro Ci per unità di tempo (ρµ),
è pari a:
Xi = Ui µi
dove tramite la legge di Little si deriva il tempo di residenza:
PN
ni pi (ni )
E [ni ]
E [ti ] =
= ni =0
Xi
(1 − pi (0)) µi
Come si nota dalle precedenti formule, tutti gli indici dipendono da N . Se la rete è vuota, ovvero N = 0,
allora non ci sono job nella rete e di conseguenza gli indici sono nulli. Tali indici sono detti indici locali,
cioè relativi al singolo centro. Mentre gli indici globali sono relativi all’intera rete.
Nel caso dell’intera rete possiamo parlare di throughput, ma essendo una rete chiusa, ovvero non c’è
un’uscita dobbiamo scegliere un punto di riferimento (anche detto centro di riferimento). Quindi la
grandezza è Xrispetto ad i = Xi .
***************INSERISCI IMMAGINE**************
Nella figura nel punto B teniamo conto di tutto ciò che esce dal centro Ci . Se invece si vuole calcolare il
throughput rispetto al punto A, ovvero rispetto ad una porzione di uscita di Ci , ad esempio se il punto
A va verso il centro Cj allora Xrispetto ad A = Xi pij .
Per quanto riguarda il tempo di risposta rispetto ad un centro Ci , ovvero E [tri ], può anche essere descritto
come il tempo da quando un job esce dal centro Ci fino a quando lo stesso job rientra nel centro Ci ed
è pari a:
E [tri ] =
M
X
νj/i E [tj ]
j=1∧j6=i
dove νj/i è il numero di visite al centro Cj rispetto ad una visita ad Ci . In altre parole quando il job
lascia il centro i, questo visiterà altri centri, quindi si prendono tutti i tempi medi che spende negli altri
centri, ma non è detto che li visiti una sola volta, quindi va messo un peso medio νj/i . Tale valore non
dipende da N , ma dalla matrice di routing. Per deteminare νj/i si possono usare le equazioni di traffico,
ovvero η̄ = η̄P , dove P è la matrice di routing. A meno di una costante si può trovare la soluzione del
sistema η̄ = {η1 , . . . , ηM }, da cui si ottiene:
νj/i =
ηj
ηi
ovvero il flusso di job nella rete si ripartisce in base a η̄, detto per questo throughput relativo. Quindi
quando si calcola il tempo di risposta bisogna escludere il tempo che il job impiega nel centro (ovvero il
tempo da quando il job esce dal centro a quando ritorna).
Il tempo di ciclo della rete dipende dal punto della rete che si prende in considerazione. Ovvero indica
quanto tempo passa da quando un job parte dal punto A della rete a quando lo stesso job ripassa per
quel punto. In formule dobbiamo sommare il tempo di risposta con il tempo di residenza, ovvero:
47
Throughput Relativo
E [tcA ] = E [ti ] +
M
X
νj/i E [tj ] = E [tri ] + E [ti ]
j=1
Il tempo di ciclo può anche essere ricavato tramite la legge di Little:
E [tcA ] =
PM
j=1
E [nj ]
Xi
=
PM
j=1
Xj E [tj ]
Xi
=
M
X
Xj
j=1
Xi
E [tj ]
Si nota che nelle reti chiuse il rapporto tra throughput relativi è uguale al rapporto tra i throughput
assoluti:
ηj
Xj
=
Xi
ηi
4.2
Capacità limitata della coda
Fin ora si è fatta l’assunzione che la coda abbia una capacità infinita. Nella realtà non sempre tutte le
richieste possono essere accettate. Una richiesta che non viene accettata per un certo istante di tempo
può anche essere persa, pertanto abbiamo bisogno di definire la probabilità di perdita.
Possiamo vedere due esempi tipici:
• Supponiamo che in sistema multiprocessore dove un centro modella i processori, un altro il bus
(senza coda), n centri che rappresentano i moduli di memoria che hanno un buffer sia in ingresso
che in uscita di capacità limitata.
Tramite il bus, i processori mandano delle richieste ai dispositivi di i/o, queste si accodano e dopo
che sono state servite vengono messe di nuovo in attesa che il bus si liberi. I meccanismi di blocco
sono in ogni singolo centro, e sono modellati in maniera diversa poiché il comportamento delle
unità cambia, i processori ritrasmettono la richiesta fino a che non trovano il bus libero, i moduli
di memoria invece si fermano se i buffer in uscita sono pieni.
• Consideriamo un sistema interattivo multi-programmato. Il blocco si applica ad un insieme di
risorse, all’interno del quale ci possono essere al più N programmi, non è possibile accoglierne altri.
Il blocco avviene a livello di sottorete, se la somma dei job all’interno dei centri della sottorete
considerata è N , il centro che si trova a monte deve essere bloccato affinché non esce almeno un
job.
A tal proposito vediamo i diversi modelli di blocco che dipendono dal tipo di comportamento che le unità
limitandosi al caso di due centri connessi da un buffer di lunghezza finita. Bisogna quindi determinare:
• il processo di Markov sottostante la rete;
• gli indici, perché potrebbero cambiare a livello di definizione nel caso di rete con blocco;
• relazioni di equivalenza tra i diversi tipi di blocco.
4.2.1
Modelli di blocco
Consideriamo due centri, Ci e Cj , dove il centro Cj ha una coda limitata. Chiamiamo Bi la dimensione
finita della coda del centro Ci incluso il job in servizio. In questo paragrafo vedremo diversi modelli di
blocco, i quali forniranno delle linee guida su come gestire un nodo che è bloccato. Si ricorda inoltre che
se nj = Bj allora il centro Cj è saturo e blocca il centro a monte Ci (non il centro Cj ).
48
Blocking After Service (BAS) Il centro Ci porta avanti il servizio indipendentemente da Cj , dopo
di che se il centro Cj è saturo il centro Ci si blocca, cioè non può servire altri job e tiene il job servito in Ci
stesso. Appena c’è una partenza da Cj simultaneamente c’è la partenza job bloccato in Ci . La rete passa
dallo stato (. . . , ni (bloccato) , . . . , Bj ) allo stato (. . . , ni − 1 (attivo) , . . . , Bj ). Bj non cambia perché la
partenza del job è simultanea. Se il centro Cj ha più centri mittente che sono bloccati allora quando
Cj si sbloccherà quale centro invierà il job in attesa? Bisogna decidere una disciplina di scheduling
per lo sblocco. Di solito prende servizio il primo centro che si è bloccato, ovvero fbfu (first blocked
first unblocked). Questo fa parte del modello bas e lo gestisce sempre Cj . In altre parole tale modello
evidenzia il comportamento del bus, ovvero appena il job termina nel centro a valle, vi è una transazione
simultanea del job che è terminato nel centro a monte.
Repetitive Service (RS) Il centro Ci porta avanti il servizio indipendentemente da Cj , quando
termina se la destinazione è satura rimanda il job nella coda dove questo, a seconda della disciplina di
scheduling, verrà rielaborato. In altre parole tale modello evidenzia il comportamento dei processori,
ovvero se il centro a valle è saturo, il job viene rimesso in coda fin quando il servizio termina e si trova
un posto libero nel centro di destinazione.
Nel caso di rs non vi è una transizione simultanea perché non c’è alcun job pronto. Ora bisogna
distinguere se il centro ha più di un destinatario, ad esempio Cj e Ck . Quando il job viene rimandato
in coda perché ad esempio Cj era saturo una volta ri-servito il job deve dirigersi a destinazione. A tal
proposito rs si specializza in:
• rs-rd (repetitive service random destination): Ogni volta che il job termina il servizio sceglie se
ritentare il centro destinatario a valle oppure se cambiare centro e tentare nel nuovo centro.
• rs-fd (repetitive service fixed destination): A seguito del blocco, il job continua a scegliere sempre
il centro al quale era destinato fin dal primo tentativo che ne ha determinato il primo blocco.
Blocking Before Service (BBS) Il centro verifica prima di iniziare un servizio se vi è spazio per
accogliere il job nella destinazione. Se non c’è spazio Ci si blocca e quando Cj avrà spazio avvisa il
centro Ci che diventa quindi attivo. Un caso particolare può essere se Cj non è saturo nell’istante in cui
Ci deve iniziare a servire un job, ma diventa saturo durante il servizio. In questo caso quando lo stato
di Cj cambia, viene riportato ad Ci che si blocca. Il servizio parziale può essere perso o meno. Il blocco
avviene prima ma può avvenire anche durante il servizio.
I centri non portano a termine il loro servizio indipendentemente dallo stato del centro destinatario, come
nei casi precedenti, ma solo al momento della partenza di un job dal centro a valle, il blocco termina e
il centro a monte invia un job. In questo caso potrebbe accadere che mentre il centro a valle si libera di
un job e sblocca il centro a monte, arriva un altro job da un secondo centro a monte. Di conseguenza il
job del centro a monte originale viene messo in attesa.
Anche in questo caso esistono delle varianti:
• bbs-so: il questo caso se il centro di partenza è pieno e viene bloccato allora si sfrutta anche il
servente per accumulare job.
• bbs-sno: al contrario del bbs-so se il centro è bloccato allora non abbiamo job nel servente.
• bss-o: simile al bbs-so solo che il job che si trova nel servente, quando il centro viene sbloccato,
riprende l’esecuzione da dove aveva lasciato.
4.2.2
Analisi dei modelli (servente singolo)
Caso RS-RD
La notazione dello stato rimane identico a quello di una rete senza blocco ovvero S = (n1 , . . . , nM ) solo
che abbiamo dei vincoli su ni .
Se una rete è aperta allora 0 ≤ ni ≤ Bi . Se invece è una rete chiusa non è detto che la popolazione di
un centro può essere nulla. Se in una rete tutti i centri sono a capacità limitata e non c’è possibilità di
allocare n job negli altri centri, rispetto al centro Ci , allora Ci non potrà mai essere vuoto. In formule:
49
max


0, N −

M
X
Bj
j=1,j6=i


≤ ni ≤ Bi

Quindi quello che resta di N mettendo tutti i centri in condizione di saturazione (la sommatoria è la
popolazione massima che può essere raccolta degli altri centri rispetto ad Ci ). Se tale differenza è positiva
vuol dire che il centro nnon può mai essere vuoto.
o
PM
Chiamiamo ai = max 0, N − j=1,j6=i Bj allora lo spazio degli stati è:
ERS−RD =
¯
)
M
¯
X
¯
ni = N
(n1 , . . . , nM ) ¯ai ≤ ni ≤ Bi , 1 ≤ i ≤ M,
¯
(
i=1
Si nota che lo spazio degli stati delle reti con blocco è più piccola di quelle senza blocco.
Esempio
Prendiamo il caso in cui M = 3, N = 5 e Bi = 3 per ogni i (vicolo massimo di 3 job per centro), come
espresso in figura:
*******************INSERIRE IMMAGINE*********
E = {(3, 2, 0) , (3, 1, 1) , (3, 0, 2) , (2, 3, 0) , (2, 2, 1) , (2, 1, 2) ,
(2, 0, 3) , (1, 3, 1) , (1, 2, 2) , (1, 1, 3) , (0, 3, 2) , (0, 2, 3)}
Ci sono meno stati rispetto ad una rete senza blocco e in nessuno c’è un centro con 4 o 5 job. Infatti la
cardinalità dello spazio degli stati nel caso di rete senza blocco è pari a:
µ
N +M −1
M −1
¶
µ ¶
7
=
= 21
2
Vediamo alcune transizioni di stato.
Nello stato (3, 2, 0) quale centro si blocca? Il centro C2 continua a rielaborare finché non si libera il
centro C1 che è saturo. Se il job parte dal centro C1 otteniamo:
(3, 2, 0) → µ1 p12 → (2, 3, 0) va in C2
(3, 2, 0) → µ1 p13 → (2, 2, 1) va in C3
Se il job parte dal centro C2 otteniamo:
(3, 2, 0) → µ2 p21 → (2, 2, 1) situazione di blocco
Vediamo ora lo stato (2, 3, 0):
• Se il job parte dal centro C1 abbiamo:
(2, 3, 0) → µ1 p12 → (2, 3, 0)
(2, 3, 0) → µ1 p13 → (1, 3, 1)
va in C2 (blocco C1 )
va in C3
• Se il job parte dal centro C2 abbiamo:
(2, 3, 0) → µ2 p21 → (3, 2, 0) va in C1
50
Vediamo che succede se nella rete abbiamo N = 6 job. Oltre a cambiare lo spazio, si può creare una
situazione di deadlock , cioè di attesa infinita: il centro C2 aspetta che si liberi il centro C1 ed il centro
C1 aspetta che si liberi il centro C2 . Questa situazione si risolve perché essendo la disciplina random,
c’è una probabilità non nulla che il job vada al centro C3 . Se la disciplina è di tipo fifo il problema non
viene risolto e il sistema va in stallo.
Per evitare il deadlock si deve imporre che:
N<
X
Deadlock
Bj
j∈ciclo minimo
Per ciclo minimo si intende il ciclo all’interno della rete la cui somma delle capacità è minima. Ad
esempio, consideriamo B1 = 3, B2 = 2, B3 = 4. Si possono mettere al più 4 (N < 3 + 2) job nella rete,
ovvero il ciclo minimo è quello formato dal centro C1 e C2 .
Caso BSS-SO
so sta per server occupied, nel senso che quando il nodo è bloccato il job bloccato può occupare il
servente del centro (non si sposta nella coda).
Si ricorda con questo modello il job dichiara la destinazione, se questa risulta satura il centro si ferma
fino a quando non si libera un posto nella destinazione. Può accadere che il blocco avviene anche durante
il servizio se la destinazione diventa satura.
La notazione dello stato si complica leggermente. Infatti, per ogni centro non vuoto bisogna specificare
a quale centro è destinato il job in corso di servizio. Lo stato sarà un insieme di M coppie dove ogni
coppia indica i job nel centro e la destinazione del job in corso di servizio:
S = {(n1 , d1 ) , . . . , (nM , dM )} 1 ≤ di ≤ M
Se la destinazione è unica, ovvero non c’è possibilità di scelta, possiamo snellire la notazione ed omettere
i di :
EBSS−SO = n
{(S1 , . . . , SM ) |Si = (ni , di ) |0 ≤ ni ≤ Bi , i ≥ 1, di ≤ M }
o Rete aperta
PM
EBSS−SO = (S1 , . . . , SM ) |Si = (ni , di ) |ai ≤ ni ≤ Bi , i ≥ 1, di ≤ M, i=1 ni = N
Rete chiusa
Esempio
Sia Bi = 3 ed N = 5. Abbiamo 22 stati. Ad esempio lo stato (3, 2, 0), nel caso del bbs, diventano 2 stati
a seconda di dove mandare il job che è in lavorazione su C1 , ovvero ((3, 2) , 2, 0) e ((3, 3) , 2, 0).
Vediamo qualche transizione di stato. Prendiamo lo stato ((3, 2) , 1, 1), i centri C2 e C3 sono bloccati
quindi solo il centro C1 può inviare un job.
Il significato della probabilità di routing in questo caso è diversa. In precedenza si aveva µi pij che
indicava: esiste un termine di servizio nel centro Ci e il job va verso il centro Cj . In questo caso la pij
è già determinata, quello che si deve scegliere è la destinazione del job successivo che entra in servizio
all’istante di tempo in cui termina il job destinato a Cj . Riprendendo la precedente transizione di stato
vediamo che:
((3, 2) , 1, 1) → µ1 p12 → ((2, 2) , 2, 1)
((3, 2) , 1, 1) → µ1 p13 → ((2, 3) , 2, 1)
ovvero il job che sta finendo in C1 ha già scelto che deve andare in C2 , lo ha deciso prima di iniziare,
quindi quando il centro C1 termina dobbiamo scegliere dove andrà il prossimo job che terminerà in C1 .
Questo di nuovo potrà andare in C2 o in C3 .
Prendiamo lo stato (0, 2, 3). Quando un job entra in un centro vuoto in quell’istante di tempo va in
servizio, quindi deve anche essere scelta la destinazione di quel job. Quindi nelle frequenze di transizioni
tra stati di bbs possiamo avere due probabilità di routing: µi pij phk .
51
Ciclo Minimo
Esempio
*************************INSERIRE IMMAGINE****************
Come si vede in figura, si deve avere che ni > 1 e che nh = 0. Il job in Ci ha destinazione Ch .
Quando il centro Ci termina, il job andrà verso Ch .
Si passa da uno stato del tipo (. . . , (ni , h) , . . . , 0, . . .) a (. . . , (ni − 1, j) , . . . , (1, k) , . . .). Di conseguenza
bisogna fare due scelte:
• La destinazione del prossimo job che entra in servizio dopo che ha terminato (nell’esempio Cj ).
• La destinazione del job che trovando il centro Ch vuoto va subito in servizio e deve scegliere anche
la destinazione di questo.
Quindi per quanto riguarda lo stato (0, 2, 3), se termina nel centro C2 abbiamo:
(0, 2, 3) → µ2 p12 p21 → ((1, 2) , (1, 1) , 3)
(0, 2, 3) → µ2 p13 p31 → ((1, 3) , (1, 1) , 3)
Caso BAS
Il centro porta a termine il servizio, se il destinatario è saturo il centro si blocca. Quando il destinatario
non sarà più saturo dovrà avvertire i centri che sono bloccati su di lui, e se è più di uno c’è anche bisogno
di una politica di scheduling.
La notazione si complica poiché dobbiamo mettere le “sveglie” nei nodi di destinazione, lo stato diventa
quindi:
Si = (ni , bi , mi )
dove:
• b indica se il centro è bloccato (0) o attivo (1);
• m è un vettore di sveglie contenente gli indici dei centri bloccati su i (magari in ordine di sblocco).
Se il centro è attivo omettiamo la componente b.
Esempio
Sia Bi = 2 ed N = 3.
E = {(2, 1, 0) , ((2, [2]) , (1, 1) , 0) , (2, 0, 1) , ((2, [3]) , 0, (1, 1)) , (1, 2, 0)
((1, 1) , (2, [1]) , 0) , (1, 1, 1) , (1, 0, 2) , ((1, 1) , 0, (2, [1])) , (0, 2, 1) , (0, 1, 2)}
Immagino di essere nello stato (2, 1, 0), possiamo avere tre casi:
1. Il job va dal centro C1 al centro C2 :
(2, 1, 0) → µ1 p12 → (1, 2, 0)
2. Il job passa dal centro C1 al centro C3 :
(2, 1, 0) → µ1 p13 → (1, 1, 1)
3. Il job esce dal centro C2 e questo centro rimane bloccato poiché il centro C1 è saturo:
(2, 1, 0) → µ2 p21 → ((2, [2]) , (1, 1) , 0)
52
Immaginiamo di essere nello stato ((2, [2]) , (1, 1) , 0), la transizione verso un altro stato può essere solo
opera del centro C1 infatti:
• il centro C3 è vuoto;
• il centro C2 non è vuoto ma è bloccato.
Il centro C1 invia la sveglia a C2 e ci sarà la transizione simultanea del job già pronto nel centro C2 .
Se il centro C1 manda il job nel centro C2 abbiamo:
((2, [2]) , (1, 1) , 0) → µ1 p12 → (2, 1, 0)
Se il centro C1 manda il job nel centro C3 abbiamo:
((2, [2]) , (1, 1) , 0) → µ1 p13 → (2, 0, 1)
Esempio
Sia Bi = 2 e N = 5 come rappresentato nella seguente figura.
******************INSERIRE IMMAGINE*****************
Qui abbiamo il caso che nessun centro può essere mai vuoto. La popolazione minima è 1. Se si ha rs-rd,
lo spazio sarebbe (2, 2, 1) , (2, 1, 2) , (1, 2, 2). Nel caso di bbs-so, ogni stato è una coppia ma il di sarebbe
fisso, ovvero d1 = 2, d2 = 3 e d3 = 1, dato che la destinazione è unica la notazione rimane invariata. Per
quanto riguarda il caso bas, gli stati sono generati nel seguente modo:
• Se il job parte dal centro C1 verso il centro C2 allora il centro C1 si blocca poiché il centro C2 è
saturo:
(2, 2, 1) → ((2, 1) (2, [1]) , 1)
• Se il job parte dal centro C3 verso il centro C1 allora il centro C1 si blocca poiché il centro C1 è
saturo:
(2, 2, 1) → ((2, [3]) , 2, (1, 1))
4.3
Definizione degli indici
Prendiamo come ipotesi un servente singolo avente coda di tipo fifo e servizi di tipo esponenziale.
L’utilizzazione effettiva tiene conto del fatto che il centro sta producendo lavoro utile (il centro non è
bloccato) e della percentuale di tempo in cui il centro non è vuoto.
L’utilizzazione classica tiene conto solo della percentuale di tempo in cui il centro non è vuoto, ovvero:
min{Bi ,N }
Ui =
X
pi (ni )
ni =1
Nell’utilizzazione effettiva si considerano tutti gli stati in cui il centro non è vuoto né bloccato. Distinguiamo quindi i seguenti casi:
• bbs:
Uie =
X
S̄:s¯i =(ni ,di ),ni >0∧(nj <Bj ,di =j)
min (ni , Ki ) ¡ ¢
π S̄
Ki
Ovvero prendiamo tutti gli stati in cui abbiamo almeno un job sul centro Ci ed il nodo destinazione
(Cj ) non deve essere saturo.
53
Utilizzazione
Effettiva
Utilizzazione
Classica
• rs:
X
Uie =
S̄:s¯i =(ni ,bi ,m̄i ),ni >0∧bi =0
min (ni , Ki ) ¡ ¢
π S̄
Ki
Ovvero prendiamo tutti gli stati che possiedono almeno un job sul centro Ci e questo stato non è
bloccato.
• rs:
X
Uie =
S̄:ni >0∧(nj <Bj ∧pij >0)
min (ni , Ki ) ¡ ¢
π S̄ pij
Ki
Se la destinazione è satura, non lo consideriamo lavoro utile, ovvero prendiamo in considerazione
solo la probabilità che il lavoro che il centro sta compiendo è utile dato che il destinatario non è
saturo.
Ricordiamo che Ki rappresenta il numero di massimo di job nel centro Ci .
Il throughput è quell’indice che indica quanti job sono smaltiti in un’unità di tempo.
Nel caso di rs, ha senso distinguere tra il throughput classico e quello effettivo, togliendo da quest’ultimo
il numero di job che per effetto del blocco tornano indietro e vengono nuovamente serviti dal centro,
ovvero:
½
Throughput
Xi = Ui Ki µi
Xi = Uie Ki µi
dove nel primo caso abbiamo il throughput classico e nel secondo caso quello effettivo.
Per gli altri tipi di blocco questa distinzione non esiste, quindi risulta:
Xi = Xie = Uie Ki µi
Il numero medio di job nel centro Ci è pari a:
Ei [n] =
Numero
di job
X
medio
ni pi (ni )
ni
Nel caso RS esiste una distinzione del tempo medio di residenza al centro, ovvero:
(
i [n]
Ti = EX
i
E
Tie = Xi [n]
e
i
Ti < Tie
Rispetto agli indici globali, quest’ultimo non cambia rispetto alla rete senza blocco. Il numero medio di
visite deve essere calcolato rispetto al throughput relativo, risolto tramite le matrici di traffico.
Se mettiamo a paragone le reti con blocco e quelle senza blocco otteniamo che l’utilizzazione ed il
throughput delle reti con blocco sono inferiori a quelli delle reti senza blocco. Mentre non si può dire
per il numero medio di job nel centro. Infatti si può avere il caso in cui il centro di destinazione è saturo
e quindi il centro di partenza si blocca e a lungo andare satura. Di conseguenza il numero medio di job
del centro saranno:
E[n]
E[n]
E[n]
solo saturo →<
solo blocco →>
entrambe →?
54
E[n]no−block
E[n]no−block
E[n]no−block
Tempo medio di
residenza
Ovvero, se è solo saturo ma non bloccato, c’è un numero inferiore di job poiché c’è un vincolo e la coda
non cresce. Se il nodo può solo bloccarsi, il numero medio di job può solo crescere a causa del fatto che
non sta producendo throughput effettivo e la coda non si svuota. Nel caso valgano entrambe le cose non
si può dire.
T⋆
?, >
Tno−block
In una rete con blocco, i T ⋆ tendono ad allungarsi ma in generale non si può dire perché dipende dai
parametri prima e da k, che è difficile da valutare.
4.4
Modelli di reti a code separabili
Esiste una classe di reti, detta separabili, in cui, pur avendo un modello a più centri, questi vengono
considerati come se agissero indipendentemente e quindi la soluzione globale è data dalla somma delle
componenti calcolate singolarmente per ogni centro. In altre parole sono reti contenenti un insieme di
centri interconnessi tra loro, ma studiabili separatamente.
Le ipotesi necessarie sono:
• Bilanciamento del flusso ai centri di servizio;
• Comportamento one-step: ad ogni istante di tempo un solo job cambia stato;
• Omogeneità:
– Routing: non dipende dallo stato dei centri coinvolti.
– Dispositivi: il tasso di servizio dei centri dipende dallo stato del centro ma non dallo stato
della rete e di conseguenza dagli altri centri.
– Arrivi esterni: dipendono dal numero dei job dei centri, ma non dallo stato della rete. Ovvero
sono indipendenti da come sono disposti i job nella rete.
Le caratteristiche che non sono incluse in questo tipo di modelli sono:
• Il possesso simultaneo di risorse: non possiamo rappresentare il fatto che un job possieda più
risorse contemporaneamente. Ad esempio il trasferimento dati da/verso il disco richiede il possesso
simultaneo del disco e del canale di comunicazione.
• Limitazione di memoria (e spazio/servizio).
• Blocco.
• Comportamento adattivo, a causa dell’omogeneità di routing ed altro.
• Creazione di processi e sincronizzazione (fork, join, . . .).
• Scheduling e classi di priorità.
Per trovare una soluzione a reti separabili con classe singola si usano: il teorema di Jackson nelle reti
aperte oppure il teorema di Gordon & Newell nelle reti chiuse. I calcoli da fare per le reti aperte risultano
più semplici rispetto a quelli delle reti chiuse perché il throughput è già noto, ovvero X = λ.
Generalizzando tali teoremi applichiamo il teorema bcmp2 per trovare una soluzione per reti miste.
In quest’ultimo caso possiamo usare distribuzioni generalizzate e possono essere presenti degli infinite
server o dei multi-serventi. Gli algoritmi di scheduling possono essere di tipo ps (processor sharing) o
altre discipline complesse. L’unica eccezione si fa per le discipline astratte, come fifo, che richiedono
una distribuzione esponenziale. Quindi possono esserci più classi di utenti e la rete può essere aperta per
alcune classi oppure chiusa per altre.
A questi teoremi si sono poi affiancati gli algoritmi risolutivi per calcolare direttamente gli indici
senza passare per il calcolo delle probabilità stazionarie di stato: convoluzione e mean value analysis
(mva).
2 Il
nome deriva dai cognomi di chi lo ha inventato.
55
4.4.1
Teorema di Burke
Consideriamo le reti aperte, il cui spazio degli stati è illimitato. Sia (n1 , n2 ) lo stato del sistema.
Quando abbiamo arrivi di Poisson e servizi esponenziali, il tasso in uscita dal centro continua ad essere
di Poisson, ovvero: π (n1 , n2 ) = π (n1 ) π (n2 ).
In altre parole, quando abbiamo una matrice di transazione infinita ed il centro ha entrate di tipo
poissoniane allora il flusso di uscite del centro risulterà ancora poissoniano.
4.4.2
Teorema
Burke
di
Teorema
Jackson
di
Teorema di Jackson
Dati M nodi esponenziali con probabilità di routing P = ||pij ||. La probabilità con cui un utente
completa il servizio sul centro Ci ed esce dalla rete è pari a:
pi0 = 1 −
M
X
pij
j=1
Chiamiamo λi il tasso medio degli arrivi al centro Ci che è composto dai job che arrivano dagli altri
centri all’interno della sottorete in esame e da γi che rappresenta i job che arrivano dalla rete esterna.
Tramite le equazioni di traffico otteniamo che il throughput assoluto è pari a:
(
PM
λi = γi + j=1 λj pji
PM
γ = i=1 γi
Se fissiamo γ otteniamo una soluzione unica, ma in questo caso otteniamo un sistema non omogeneo.
Se sono soddisfatte le condizioni di stazionarietàQallora la distribuzione stazionaria è data dal prodotto
M
delle singole soluzioni, ovvero π(n1 , n2 , . . . , nM ) = i=1 πi (ni ). Dato il tempo di servizio esponenziale di
parametro µi , disciplina di servizio fifo e considerando il teorema di Burke (vedi il precedente paragrafo)
allora troviamo la formula di Erlang:
πi (0) =
·
Pmi −1
ni =0
“
λi
µi
”n
ni !
λi
mi µi<
i
+
1
³ ´ni
 πi (0) λi
³ µi ´ni
πi (ni ) =
 πi (0) λi
µi
ρi =
“
λi
µi
”m
i
mi (1−ρi )
¸−1
1
ni !
se ni ≤ mi
1
n −mi
mi !mi i
altrimenti
dove ni è il numero di utenti ad un certo istante presenti nel centro Ci , mentre mi è il numero di
processori nel centro Ci .
Per calcolare π (n1 , . . . , nM ) è sufficiente conoscere i coefficienti di utilizzazione ρi ed una volta ottenuti
i λi si ottiene diPconseguenza anche π (n̄), dato che i valori di µi sono forniti dal problema. Inoltre
ricordiamo che: n̄∈E π (n̄) = 1.
La complessità di questo algoritmo è pari a O(M ), mentre la complessità della soluzione trovata tramite
Markov è pari a O(E 3 ).
La popolazione media del centro Ci in una rete aperta è pari ad E [ni ], mentre il numero medio delle
visite al centro Ci a λγi , dove il throughput relativo è λi . Tramite questo risultato possiamo calcolare il
tempo che intercorre tra quando il job entra nella rete a quando esce, ovvero:
E [tr ] =
PM
M
E [ni ] X λi
=
E [ti ]
γ
γ
i=1
i=1
56
Esempio
Sia una rete di Jackson con µ1 e µ2 esponenziali. λi rappresenta il throughput del centro Ci . Per trovare
tale indice scriviamo le seguenti equazioni di traffico:
½
λ1 = γ + λ2
⇒
λ2 = (1 − p)λ1
½
λ1 = γp
λ2 = (1 − p) γp
Il throughput dei due centri dipende da γ, ovvero ciò che arriva. Secondo Jackson, π(n1 , n2 ) =
π1 (n1 )π2 (n2 ), con πi (ni ) = πi (0)ρni i = (1 − ρi )ρni dove i = 1, 2 e ni > 0. Di conseguenza E[ni ] = E[q] =
E[w] + ρ che per un servente singolo diventa pari a
4.4.3
ρ2i
1−ρi
+ ρi =
ρi
1−ρi .
Mentre E[tqi ] =
E[ni ]
λi
=
1
µi −λi .
Teorema di Gordon & Newell
Consideriamo adesso i modelli a reti chiuse. In questo tipo di rete non c’è γ e quindi il calcolo per trovare
la soluzione risulta un pò più complesso. Per calcolare il numero medio di visite dobbiamo innanzitutto
trovare il tempo di risposta globale, ovvero moltiplichiamo i singoli tempi di risposta per il numero
medio di visite. Nel caso della rete di Gordon & Newell abbiamo una rete chiusa in forma prodotto dove
abbiamo M centri con tasso di servizio esponenziale di parametro µi e disciplina di servizio fifo. Il
numero di job nella rete è pari P
a N ed ogni job circola nella rete seguendo una matrice di routing P in
M
cui vale la seguente relazione:
j=1 pij = 1, ∀i ∈ [1, M ]. Sia quindi n = (n1 , n2 , . . . , nM ) lo stato del
modello allora avremo il seguente spazio degli stati:
E=
¯M
)
¯X
¯
(n1 , . . . , nM ) ¯
ni = N, 0 ≤ ni ≤ N, i = 1, . . . , M
¯
(
i=1
Essendo la rete chiusa, l’equazione di traffico corrisponde al throughput relativo del centro Ci , ovvero:
ηi =
M
X
ηj pij
j=1
Dai throughput relativi si passerà al calcolo dei throughput assoluti solo dopo la soluzione della forma
prodotto.
Descriviamo quindi una formula che dipende dal numero di job nei singoli centri:
βi (ni ) =
½
ni !
mi !mini −mi
se ni ≤ mi
se ni > mi
Secondo il teorema di Gordon e Newell abbiamo:
Teorema
di
Gordon-Newell
¶n
M µ
1 Y ηi i 1
π(n1 , n2 , . . . , nM ) =
G(N ) i=1 µi
βi (ni )
per ogni n̄ ∈ E. G(n) rappresenta la costante di normalizzazione ed è la parte computazionalmente più
onerosa da trovare dato che per ogni elemento della sommatoria bisogna fare una produttoria:
G(n) =
¶n
M µ
XY
ηi i
π∈E i=1
µi
1
βi (ni )
Esistono comunque algoritmi risolutivi più efficienti per il calcolo di questa costante.
57
Esempio
Supponiamo di avere M centri con tempi di servizio esponenziali, scheduling di tipo fifo a servente
singolo. Sia inoltre η1 = η2 = . . . = ηM = 1 e µ1 = µ2 = . . . = µM = µ.
β è pari ad 1 dato che è a servente singolo quindi otteniamo:
M
1 Y 1
G(N ) i=1 µni
π (n̄) =
Se invece avevamo ηi = µi = µ allora la formula diventa:
4.4.4
π (n̄) =
1
G(N )
G(N ) =
P
Distribuzione marginale
QM
1
i=1 1 = G(N )
Q
M
π∈E
i=1 1 = |E|
Sia le soluzioni di una rete applicando Markov che quelle del modello in forma prodotto siamo in grado
di calcolare le probabilità stazionarie degli stati del sistema e da queste possiamo trovare le probabilità
marginali, ovvero:
pi (n) =
X
π̄(n1 , n2 , . . . , nM )
π̄:ni =n
Nel caso delle reti aperte di Jackson, la soluzione è già espressa come prodotto delle marginali:
π (n1 , . . . , nM ) =
M
Y
πi (ni )
i=1
Mentre nelle reti chiuse, non siamo in grado di ottenere le distribuzioni marginali dei singoli centri tramite
il teorema di Gordon & Newell.
4.4.5
Utilizzazione
Tramite la soluzione con le catene di Markov siamo in grado di conoscere l’utilizzazione dei singoli centri:
• Per servente singolo:
ρi (N ) =
N
X
pi (ni ) = 1 − pi (0)
ni =1
• Per servente multiplo:
mi −1
N
X
1 X
ρi (N ) =
pi (ni )
ni pi (ni ) +
mi n =1
n =m
i
i
i
Nel caso degli Infinite Server otteniamo una “fusione” delle due sommatorie dove mi = N , di
conseguenza ρ(N ) decresce al crescere di N . In formule:
ρi (N ) =
N
1 X
ni pi (ni )
N n =1
i
58
4.4.6
Throughput locali
Per il servente singolo abbiamo:
λi (N ) = µi ρi (N )
mentre per il servente multiplo:
λi (N ) = mi µi ρi (N )
Per gli infinite server abbiamo λi (N ) = N µi ρi (N ).
4.4.7
Tempi di residenza
I tempi di residenza si ricavano dalle leggi di Little.
4.4.8
Teorema BCMP
Questo teorema si applica per le reti miste, ovvero in reti in cui i job vengono suddivisi in più classi in
base al tempo di servizio del centro oppure in base al comportamento del centro. In altre parole come
se avessero più matrici di routing. Per alcune classi di job la rete è chiusa, per altre è aperta, ovvero
abbiamo una popolazione variabile che è legata ad una matrice di routing che possiede le probabilità di
uscita. Quindi rappresenta un modello multiclasse con:
• routing probabilistico ed indipendente dallo stato: non ci sono comportamenti adattivi;
• il tempo di servizio deve essere esponenziale in caso di scheduling astratto con accodamento. Mentre
se non c’è accodamento, come nel caso di ps (time sharing) o is o lifo-prelazionata, si deve usare
una distribuzione generale. In pratica si usa una coxiana, la quale approssima le distribuzioni
generali in modo esatto se si hanno un numero di stati infinito e si possiede la trasformata di
Laplace razionale, ovvero come se si avesse una erlangiana in cui si può uscire da ogni stato.
Abbiamo quattro tipi di centro:
Tipo 1 Esponenziale astratto: la grossa limitazione è che è indipendente dalla classe. Il tempo di
servizio è associato al centro, non al job. Il µ, però, può dipendere dallo stato e quindi dal numero
di job presenti nel centro Ci .
Tipo 2 Coxiano con is.
Tipo 3 Coxiano con ps: ogni job riceve N1 della capacità di µ. Nel caso di serventi multipli la classe
può indicare tempi diversi in base al particolare centro.
Tipo 4 Coxiano con lifo-prelazionato: si usa un servente singolo.
I primi tre tipi possono includere serventi multipli, anche se nel caso di ps è un servente “condiviso”.
La distribuzione stazionaria di stato per reti bcmp si può esprimere come:
π (n1 , . . . , nM ) =
dove:
M
Y
1
fi (ni )
d (n)
G
i=1
QM
i=1 fi (ni )
Qn−1
γ(k)
per reti aperte
k=0 Q
QR
d(n) =
nr −1
γr (k) per reti miste
( r=1Q k=0ρnir
R
ir
ni ! r=1 nir ! per nodi di tipo 1, 3, 4
fi (ni ) =
QR ρnirir
per nodi di tipo 2
r=1 nir !
G=
P
n∈E
(
Se per le reti chiuse la matrice P è irriducibile, la soluzione esiste sempre, mentre per le reti aperte e
miste la condizione sufficiente per la stazionarietà è G < ∞.
59
Teorema
BCMP
MVA
mva è il metodo più veloce per la soluzione di reti bcmp, che si applica alla stessa classe di reti. Con
il teorema bcmp si ha una formula complessa, ovvero che cambia a seconda del tipo di centro, mentre
usando mva non si ottiene la probabilità stazionaria degli stati ma direttamente gli indici locali. In questo
modo si evita di calcolare la costante di normalizzazione G(N ) e quindi si eliminano tutti i problemi
di instabilità numerica. Solo se tali equazioni sono dipendenti dal carico allora si ottengono soluzioni
numericamente instabili.
Gli indici locali che si possono trovare sono il tempo di residenza, il throughput dei centri e la loro
popolazione media. Non fornisce però l’utilizzazione, ma possiamo ricavarla dal throughput con le leggi
“inverse”.
Assumiamo che la rete sia separabile ed i tassi di arrivo siano indipendenti tra loro. Inoltre, supponiamo
di avere M centri ed N job, allora il tempo di risposta E [ti (N )] è pari al tempo da quando il job entra
nel centro Ci a quando lo stesso job esce da quel centro. In altre parole è il tempo speso in servizio
sommato al tempo speso in attesa che gli “altri” utenti terminino il servizio, ovvero Ts + Tw . Questo
valore è funzione del numero di job nella rete ed è pari a:
E [ti (N )] = E [tsi ] (1 + E[ai (N )])
dove E [ai (N )] rappresenta il numero medio degli altri job che stanno davanti. Tale media viene fatta
sugli istanti di arrivo.
Nelle reti separabili vale il teorema degli arrivi: E[ai (N )] = E[ni (N − 1)], ovvero specifica che il numero
di utenti in arrivo è pari al numero di job nella rete in ogni istante di tempo eccetto il job che stiamo
considerando. Questo teorema fornisce la chiave per la soluzione del problema, infatti con una semplice
ricorsione si parte dalla rete nota e poi si calcolano gli indici per N = 1, N = 2, . . . Quindi possiamo
riscrivere il tempo di risposta nel seguente modo:
E [ai (N )] = E [ni (N − 1)] ⇒ E [ti [N )] = E [tsi ] (1 + E [ni (N − 1)])
Di conseguenza in tempo lineare è possibile calcolarsi tutti gli indici.
Supponiamo che µ è uguale per ogni centro Ci . La capacità è dunque indipendente dal carico. Il tempo
di residenza ad un centro, per qualsiasi rete, sarebbe dato applicando proprio il teorema degli arrivi.
Quindi questo teorema è la base per mva.
A questo punto vogliamo calcolare le iterazioni in base al numero di job, partendo da zero. Il throughput
del centro Ci viene calcolato come il throughput della rete, quindi il tempo di risposta della rete è
rappresentabile come tempo di ciclo nel punto i:
λi (N ) = PM
N
j=1 νj/i E [tj (N )]
Una volta trovati i throughput ed i tempi, applicando Little troviamo il terzo indice, ovvero la popolazione
media:
η
νj/i = ηji
η̄ = η̄P
E [ni (N )] = λi (N )E [ti (N )]
L’algoritmo è quindi il seguente:
for i=1 to M do
E[n[i][0]] = 0
# facciamo ora un grande ciclo sui valori
# di popolazione in cui calcoliamo tempi,
# throughput, popolazioni medie
for n=1 to N do
for i=1 to M do
60
Teorema
arrivi
degli
if centro in ritardo then
E[t[i][n]] = E[ts[i]]
else if centro in accodamento then
E[t[i][n]] = 1 + E[n[i][n-1]]
endif
done
for i=1 to M do
lambda[i][n] = N/somme(j=1 to N, v[j][i]*E[t[j][n]])
E[n[i][n]] = lambda[i][n]*E[t[i][n]
done
done
Esempio
Sia M = 3, N = 3 e µ1 = 1j/s, µ2 = µ3 = 2j/s. Avente la seguente matrice di routing:

0
P = 0
0.3
1
0
0.7

0
1 
0
Tutti i e tre i centri sono di tipo esponenziale con scheduling di tipo fifo.
**********INSERIRE IMMAGINE********

 η1 = 0.3η3
η2 = η1 + 0.7η3

η3 = η2
Fissando η3 = η2 = 1, otteniamo η1 = 0.3. Tramite queste informazioni siamo in grado di calcolarci il
rapporto tra visite:
ν1/1 = 1
ν1/2 = 0.3
ν1/3 = 0.3
1
= 3.333
ν2/1 = 0.3
ν2/2 = 1
ν2/3 = 1
1
ν3/1 = 0.3
= 3.333
ν3/2 = 1
ν3/3 = 1
Si nota che i numeri medi di vista sono uguali per i centri C2 e C3 , pertanto un passaggio sul centro C2
corrisponde ad un passaggio sul centro C3 .
In mva, la generazione degli stati non serve quindi procediamo con l’applicazione dell’algoritmo. Nella
prima fase inizializziamo E [n1 (0)] = E [n2 (0)] = E [n3 (0)] = 0. A questo punto iniziamo il “ciclo
grande” ottenendo i seguenti valori per il primo passo:
E [t1 (1)] = E [ts1 ] (1 + E [n1 (0)]) = E [ts1 ] = 1
E [t2 (1)] = E [ts2 ] = 0.5
E [t3 (1)] = E [ts3 ] = 0.5
In base ai valori che abbiamo trovato otteniamo:
1
λ1 (1) = 4.33
= 0.23
E [n1 (1)] = 0.23 · 1 = 0.23
1
λ2 (1) = 1.3
= 0.77
E [n2 (1)] = 0.77 · 0.5 = 0.39
1
λ3 (1) = 1.3
= 0.77
E [n3 (1)] = 0.77 · 0.5 = 0.39
Dai risultati ottenuti si nota che il centro C2 possiede una popolazione media più alta rispetto al centro
C1 anche se quest’ultimo è più lento del centro C2 .
Nel secondo passo abbiamo:
E [t1 (2)] = 1.23
E [t2 (2)] = 0.7
61
E [t3 (2)] = 0.7
otteniamo quindi:
2
= 0.34
λ1 (2) = 5.89
E [n1 (2)] = 0.34 · 1.23 = 0.42
2
λ2 (2) = 1.77
= 1.13
E [n2 (2)] = 1.13 · 0.7 = 0.79
2
λ3 (2) = 1.77
= 1.13
E [n3 (2)] = 1.13 · 0.7 = 0.79
Infine con l’ultimo passo dell’algoritmo otteniamo:
E [t1 (3)] = 1.42
E [t2 (3)] = 0.9
E [t3 (3)] = 0.9
e svolgendo gli opportuni calcoli per gli indici abbiamo:
3
= 0.4
λ1 (3) = 7.41
E [n1 (3)] = 0.4 · 1.42 = 0.57
3
λ2 (3) = 0.23
= 1.15
E [n2 (3)] = 1.35 · 0.9 = 1.22
3
λ3 (3) = 2.23
= 1.35
E [n3 (3)] = 1.35 · 0.9 = 1.22
Una verifica che si usa fare per controllare se ci sono errori è, ad esempio, controllare che la somma delle
popolazioni faccia N :
N = E [n1 (N )] + E [n2 (N )] + E [n3 (N )]
Come abbiamo detto mva non fornisce direttamente le utilizzazioni quindi utilizziamo Little ottenendo:
U1 = ρ1 = λ1 E [ts1 ] = 0.4
U2 = U3 = 0.675
A questo punto si possono confrontare i risultati con quelli della stessa rete, ma con capacità finita. In
quest’ultimo caso l’andamento degli indici hanno un comportamento migliore, ma in una rete con blocco
potremmo avere degli effetti contrastanti. Ad esempio potrebbe andare meglio perché si riducono le
popolazioni medie, ma in questo caso non avviene perché N = 3 è piccola.
4.5
Decomposizione/Aggregazione
Per modellare sistemi di grandi dimensioni difficilmente possiamo analizzarli con metodologie dirette a
causa dell’elevata complessità richiesta. La modellazione gerarchica tende a ridurre tale complessità,
aggregando parti del sistema in centri aggregati a flusso equivalente. La parte che interessa meno viene
cosı̀ sostituita da un unico centro.
La decomposizione e aggregazione (d/a) si articola in quattro passi:
1. decomposizione del modello in sottomodelli;
2. analisi dei sottomodelli e trasformazione in centri equivalenti;
3. produzione del modello aggregato;
4. analisi del modello aggregato, ovvero produrre la soluzione.
Questo metodo può essere applicato sia a reti con code separabili che direttamente al processo di Markov.
Inoltre funziona sia per reti chiuse che aperte.
Nel caso di modelli a classi multiple, lo scheduling diventa più complesso poiché deve gestire la presenza
di più classi. Ma questo modello si può applicare su più classi di job in modo iterativo. Le assunzioni
che vengono fatte per questo metodo sono:
• Assunzione di decomponibilità: il tasso di servizio del centro aggregato dipende solo dal numero
di job nell’aggregato, non dalla distribuzione dei job nell’aggregato. Quindi vi è un’indipendenza
dello stato iniziale.
62
• Assunzione di equilibrio locale: l’aggregato raggiunge l’equilibrio locale se fornisce gli stessi indici
del modello originale a meno di un certo errore numerico. Se questa assunzione non è valida allora
non c’è neanche l’indipendenza della disposizione dei vari job nei centri.
Per le reti in forma prodotto, il metodo è esatto. È chiaro infatti che in questo tipo di rete l’equilibrio
si raggiunge sempre e di conseguenza è garantita anche l’indipendenza dei singoli centri. Di solito si ha
l’equilibrio se ci sono molte interazioni dentro l’aggregato rispetto a quelle fra i vari sottosistemi. Ad
esempio le interazioni interne sono di un ordine di grandezza maggiore rispetto a quelle esterne.
Bisognerebbe vedere la distribuzione della variabile aleatoria del tempo di residenza nell’aggregato, ma
ci si può accontentare della media.
All’atto pratico il procedimento consiste nel decomporre la rete in S e S̄, ovvero la rete che dobbiamo
mantenere e quella da sostituire rispettivamente. Se abbiamo M centri pari a M = k + m allora
S = {Mi1 , . . . , Mik } mentre S̄ = {Mi1 , . . . , Mim }.
Per la rete S̄ dobbiamo costruire un “cortocircuito”, dato che non possiamo più passare per S. Quindi
vengono sostituite tutte le interazioni con un unico arco.
A questo punto dobbiamo costruire la nuova matrice di routing in k + 1 passi. Sia P (1) = P la matrice
di routing originaria. Al primo passo togliamo un centro appartenente a S, ma teniamo conto del
passaggio di job nel centro appena tolto. Ovvero se cortocircuitiamo il centro M1 eseguiremo la seguente
operazione:
(1)
(1)
(2)
(1)
pij = pij +
piM1 pM1 j
(1)
1 − pM1 M1
(1)
a denominatore usiamo 1 − pM1 M1 per normalizzare le probabilità, nel nostro caso è 1 se non ci sono
archi di riciclo.
Iteriamo questa trasformazione ed in k passi arriviamo alla matrice P (k+1) cortocircuitando tutti i k
centri.
Ora che abbiamo isolato S̄ ne calcoliamo il throughput medio tramite il teorema di Norton:
Sia dato un modello a rete di code in forma prodotto, partizionato nelle due sottoreti S ed S̄
con matrice di probabilità di routing P , funzioni dei nodi fj (n) per ogni nodo j e probabilità
di stato π. Si consideri il modello aggregato ottenuto dal modello originale sostituendo la
sottorete S̄ con un unico nodo C con disciplina di servizio fifo e distribuzione del tempo di
servizio esponenziale con tasso dipendente dal carico µC (n) definito come segue:
µC (n) =
m
X
Xi (n)
k
X
piMj
j=1
i=1
dove Xi (n) denota il throughput del nodo i ∈ S, quando nella rete circolano n utenti, la
matrice delle probabilità di routing P ′′ e le funzioni dei nodi di S sono definite come nella
rete originale. Sia πA la probabilità di stato allora i due modelli sono equivalenti, ovvero:
X
πA (n1 , n2 , . . . , nm , nC ) =
π(n)
n̄:
P
j∈S̄
nj =nC
per ogni stato.
Quindi si ottiene un centro dipendente dal carico.
Se il numero di iterazioni è molto alto prima che la popolazione cambi, si è indipendenti dallo stato
iniziale. Quindi l’equilibrio di S̄ è inteso come stazionarietà della soluzione, ovvero è indipendente dalla
disposizione iniziale dei job.
La nuova matrice di routing viene quindi calcolata secondo le seguenti operazioni:
p′′ij = P
pij
m
p′′ic = h=1 pih
p′′cc = 0 P
m
η p
Ph hj
p′′cj = Pm h=1
phi
ηh
h=1
i∈S
63
∀i, j ∈ S
∀i ∈ S, ∀h ∈ S̄
Teorema
Norton
di
Pm
dove h=1 ηh rappresenta tutto il flusso che va verso l’insieme dei centri in S.
La complessità computazionale di questa tecnica è la seguente:
• Soluzione equazioni di traffico η̄ = η̄P : O(M 3 ).
• µc (n) per n = 0, . . . , N : O(|S̄|N ).
• Calcolo di P ′′ e soluzione della rete aggregata: O((|S| + 1)N ).
Esempio
Sia una rete chiusa con due cpu ed un certo numero di dischi.
*********INSERIRE IMMAGINE pag 47********
Ci sono N utenti che circolano indefinitamente. La parte che interessa meno è quella dei dischi che
vogliamo conoscere solo a livello macroscopico, ovvero il tempo impiegato prima di tornare sulla cpu.
Per la rete complementare, l’aggregato è solo una scatola nera dove interessa solo il tempo di residenza
dell’aggregato e la frequenza con cui questo viene lasciato dai job.
Quindi isoliamo la parte dell’aggregato e calcoliamo il throughput al variare di N , che diventerà il tasso
di servizio.
**********INSERIRE IMMAGINE aggregata*******
Esempio
Gli utenti sono rappresentati come Infinite Server. Abbiamo i seguenti centri:
• C1 : postazione di accesso;
• C2 e C7 : sono il ritardo rovuto alla rete;
• C3 e C5 : rappresentano i Web server;
• C4 e C6 : rappresentano i database.
Inoltre abbiamo il livello di multiprogrammazione (mpl) fissato a 3, ovvero ci spossono essere al massimo
3 transazioni contemporanee.
******Inserire immagine progetto 2008/2009*******
Da una parte si voleva risolvere tramite Markov la rete in modo esatto. Il passo successivo era quello di
usare il metodo di decomposizione/aggregazione e confrontarlo con quello di Markov.
Sia S = {C1 , C2 , C7 } ed S̄ = {C3 , C4 , C5 , C6 }.
Dai risultati ottenuti tramite Markov si nota che i risultati sono stati buoni fin quando le probabilità di
blocco non sono diventate troppo alte.
La matrice di routing originale è:

P (1)




=




0
0
0
0
0
0
1
1
0
0
0
0
0
0
0
0.5
0
0.7
0
0
0
0 0
0 0.5
1 0
0 0
0 0
0 0.7
0 0
Cortocircuitiamo il centro C1 ottenendo ad esempio:
(2)
(1)

0 0
0 0 

0 0 

0 0.3 

1 0 

0 0.3 
0 0
(1) (1)
p72 = p72 +
p71 p12
(1)
1 − p11
=1
Quindi al termine del primo passo otteniamo la seguente matrice:
64
P (2)




=



0 0.5
0 0
0 0.7
0 0
0 0
1 0

0 0
0 0 

0 0.3 

1 0 

0 0.3 
0 0
0 0.5
1 0
0 0
0 0
0 0.7
0 0
Procediamo con il cortocircuitare il centro C2 :
(3)
(2) (2)
(2)
p73 = p73 +
(3)
p75
=
(3)
p73
p72 p23
(2)
1−p22
= 0.5
= 0.5
Ottenendo la seguente matrice:



P (3) = 


0
0.7
0
0
0.5
1 0
0 0
0 0
0 0.7
0 0.5
0
0
1
0
0
0
0.3
0
0.3
0






Infine cortocircuitiamo il centro C7 dove i centri coinvolti sono C3 , C4 , C5 , C6 , C7 :
(4)
(3) (3)
(3)
p47 p73
(3)
1−p77
(3) (3)
p47 p75
(3)
1−p77
(3) (3)
p67 p73
(3)
1−p77
(3) (3)
p67 p75
p43 = p43 +
(4)
p45 = p45 +
(4)
p63 = p63 +
(4)
p65 = p65 +
(3)
= 0.85
(3)
= 0.15
(3)
= 0.15
(3)
= 0.85
1−p77
Ottenendo di conseguenza la seguente matrice:
P (4)

0
 0.85
=
 0
0.15
1
0
0
0
0
0.15
0
0.85

0
0 

1 
0
La rete dell’aggregato va in deadlock se possiede n ≥ 16, quindi consideriamo solo i casi in cui n ∈ [0, 16],
mentre applicando il modello markoviano no.
A questo punto per risolvere il problema eseguiamo i seguenti calcoli:
• generiamo il nuovo spazio dei possibili stati,
• costruiamo la matrice di transazione di stato,
• diamo in pasto ad un risolutore per matrici sparse,
• infine troviamo i parametri che ci interessano (leggi throughput).
65
4.6
Quality of Service e Performance
La quality of service (qos) è l’effetto collettivo della prestazione del servizio che determina il grado di
soddisfazione per il servizio richiesto. Dal punto di vista del sistema, la qos è la capacità di un sistema
di garantire un certo livello di servizio. Ci sono varie entità coinvolte:
• Utente: si valida il servizio secondo l’aspettativa, ovvero l’utente specifica delle richieste anche in
modo non tecnico. Tali requisiti vengono trasformati in requisiti di qos. Ad esempio impostare un
limite massimo per il download di un file.
• Service Provider : i valori di interesse sono l’alta disponibilità ed il throughput del server. Quindi
specifica la qualità del servizio in un contratto, il service level agreement.
• Sistema: applicazione, reti e server, . . . che devono funzionare in modo efficiente.
Le caratteristiche della qos riguardano alcuni aspetti della qualità del sistema che possono essere identificati e quantificati. Queste sono definite indipendentemente da come può essere poi può essere rappresentata e controllata la qualità. Quindi sono le variabili di controllo da gestire. Ad esempio la capacità
della rete o il ritardo tra due nodi.
Le categorie della qos rappresentano gli ambiti applicativi in cui si possono collocare i requisiti della
qos. Quindi si suddividono l’insieme delle caratteristiche in sottoinsiemi significativi per particolari
ambiti applicativi. Tali sottoinsiemi possono avere intersezione non nulla. Ad esempio, tra le categorie
troviamo: sicurezza, sefety critical, time critical.
Per gestire la qos bisogna usare funzioni che rappresentano le attività per il controllo ed amministrazione
della qos. Ogni funzione deve soddisfare uno o più requisiti di qos e possiede diversi componenti chiamati
meccanismi. Tali meccanismi vengono eseguiti da una o più entità. Le attività di gestione prevedono tre
fasi:
1. Predizione: si cerca di predire gli aspetti comportamentali del sistema in modo che le entità possano
inizializzare i meccanismi di qos appropriati.
2. Inizializzazione: si creano le condizioni tali che i valori desiderati delle caratteristiche di qos vengano
raggiunti da parte di alcune attività di sistema prima che l’attività stessa abbia inizio.
3. Fase operazionale: l’obiettivo è quello di soddisfare gli accordi presi o eseguire azioni appropriate
per raggiungere gli obiettivi.
Di queste tre fasi, il ruolo della modellistica è centrale o utile nella prima ed ultima fase.
La qos maintenance mantiene durante il funzionamento del servizio la qos ai livelli concordati e ritenuti
accettabili.
L’obiettivo della gestione della qualità è quindi quello di accorciare le distanze tra due punti di vista:
distanza tra richiesta e percezione, distanza tra promessa e risultati raggiunti.
Nella fase operazionale troviamo i seguenti meccanismi di qos maintenance:
66
• Allocazione delle risorse: tale meccanismo non è invocato solo nell’inizializzazione, ma anche nella
fase operazionale.
Ad esempio l’algoritmo mats alloca le risorse (banda) durante la fase operazionale.
• Admission Control: fa sı̀ che non ci sia troppa competizione. In questo meccanismo si individuano
di solito due classi:
1. real-time: ad esempio traffico voce e video;
2. non real-time: ad esempio traffico dati. In questo caso una garanzia della banda minima può
essere sufficiente.
Viene calcolata la probabilità di blocco delle diverse classi, in più consideriamo la mobilità del
sistema che deve allocare banda.
Per handoff intendiamo un utente che ha già in piedi una connessione ma, ad esempio, cambia cella
e chiede risorse alla nuova cella per continuare la comunicazione. Queste richieste hanno maggiore
priorità rispetto alle nuove chiamate presenti all’interno della cella.
• System Tuning: prevede la messa a punto del sistema gestendo, a run-time, i parametri di controllo
per un dato requisito in maniera compensatoria. Dato che tale gestione avviene a run-time allora
si devono usare modelli efficienti nel tempo.
Il tuning è composto da quattro passi:
1. dai requisiti della qos bisogna derivare e tradurre dei requisiti di prestazione;
2. vengono misurate le prestazioni del sistema;
3. si valuta la differenza tra la prestazione richiesta e quella reale;
4. si fa un reset del sistema con la giusta modifica dei parametri di controllo.
Esempio
Abbiamo due classi di utenti, dove ogni cella C ha una quantità fissa di banda e non c’è coda. La prima
classe, che è di tipo real-time, ha la specifica che ogni chiamata deve avere una quantità fissa di banda.
Mentre la seconda classe può accontentarsi della parte rimanente e i suoi utenti la condividono. Quindi
la prima classe può operare preemption sulla seconda classe.
Per gestire tale problema viene messa una soglia fissa per gli utenti della seconda classe, ovvero una
porzione di banda strettamente riservata alla seconda classe in modo da non penalizzarla troppo.
Possiamo inoltre aggiungere un’ulteriore informazione sullo stato del sistema in modo tale da gestire i
casi critici del sistema. Ad esempio se la quantità di banda consumata dalla prima classe è inferiore a
quella dettata dalla soglia, mentre quella della seconda classe è satura, il sistema va in overload e quindi
bisogna cambiare soglia, ovvero si dà più spazio alla seconda classe. Ciò viene applicato finché non si
torna a situazioni di carico normali.
L’obiettivo di queste politiche è quello di minimizzare le probabilità di blocco. Supponiamo che abbiamo
un’unità di banda/lavoro per utente ed n1 rappresenta il numero di utenti della classe c1 allora possiamo
utilizzare il modello markoviano specificando la frequenza di servizio della classe c1 come n1 µ1 mentre
quella della classe c2 pari a (C − n1 ) µ2 . Ovvero la seconda classe lavora come un processor sharing, con
rallentamento in caso di più utenti, ma la frequenza di uscita rimane la stessa.
A questo punto impostiamo un limite n2 < N2 sulla classe c2 ottenendo una frequenza di servizio per
1 )µ2
. Di conseguenza la variabile di controllo è rappresentata dalla
ogni utente pari ad almeno (C−n
N2
quantità totale di banda usata dalla classe c1 . Abbiamo quindi i seguenti obiettivi:
1. Minimizzare e ricombinare linearmente le due probabilità: HPblock (1) + LPblock (2) con H ed L
positivi.
Per risolvere tale problema possiamo utilizzare la classe delle politiche generalizzate per isteresi
(ghp) in cui applichiamo un processo di Markov decisionale. Ovvero ogni stato del processo di
Markov rappresenta una possibile scelta.
L’ottimo si ha con politiche a soglia fissa, che basano la decisione solo sul livello di occupazione.
67
Handoff
2. Minimizzarne una, ma con un vincolo sull’altra, ovvero:
min {Pblock (1)}
min {Pblock (2)}
Pblock (2) ≤ P ′
Pblock (1) ≤ P ′
Il processo di Markov usato è del tipo standard, dove si hanno i job di classe c1 e j di classe c2 .
Nello spazio degli stati si ha che i ≤ C e j ≤ N2 . In questo caso se si accetta un arrivo dalla classe
c1 allora il processo transita nello stato (i + 1, j), mentre se si rifiuta un arrivo dalla classe c1 allora
il processo transita nello stato ((i, j). Quindi si ottiene:

 λ1
pλi
λ1 (i) =

0
se i < N2
se i = N2
altrimenti
dove p è la probabilità di accettare gli utenti della classe c1 quando si hanno N2 job. Mentre
µ2 (i) = (C − i)µ2 , ovvero la classe c1 non vede la classe c2 .
Per il calcolo delle probabilità di blocco della classe c1 abbiamo:
Pblock (ni p) = (1 − p)π(n) + π(n + 1)
Mentre per il calcolo della probabilità di blocco della classe c2 il procedimento è un pò più complicato, infatti bisogna dimostrare che Pblock (1) è decrescente in funzione della soglia stazionaria, al
contrario la Pblock (2) è crescente rispetto a tale soglia. Ovvero più si allarga la classe c1 meno si
riesce ad entrare nella classe c2 .
Quindi il risultato ottimo consiste nell’utilizzare politiche a soglia frazionaria, ovvero un algoritmo
che permette la determinazione della soglia ottima.
Il tuning è la fase di compensazione e modifica della variabile di controllo su cui agire. Il tuning on-line
potrebbe essere diretto da modelli di prestazione.
La gestione della qualità, nell’esempio precedente, è la gestione della banda secondo un meccanismo di
upgrading o downgrading dei modelli di servizio. La rete è composta da un insieme di base station e
switching center più un insieme di terminali mobili.
Lo scopo della bssc (politica) è mantenere in piedi la connessione degli utenti mobili che sono in una
determinata cella.
Chiamiamo C la quantità fissa di banda. Ogni utente ha livelli di servizio flessibili e può avere un
livello alto od uno basso. In questo caso non abbiamo più classi di utenti, ma un unico tipo di utente a
determinati livelli di qualità.
La banda totale C viene suddivisa in C1 e C2 . C1 è allocata agli utenti di alto livello, mentre C2 a quelli
di basso livello. In condizioni limite, serviranno tutti a livello basso e la soglia tra C1 e C2 sale. Ad
esempio una data politica C1 − C2 può essere cambiata in una C1′ − C2′ in cui C2′ è maggiore di C2 e C1′
minore di C1 ; quindi cresce il numero di utenti in relazione di questa.
Supponiamo di avere N terminali mobili, v1 sarà il segmento di banda necessario per il livello alto,
mentre v2 per il livello basso. Con v1 e v2 possiamo calcolare quanti utenti si possono servire a livello
alto e basso:
j k
M = Cv11
j k
S = Cv22
N =M +S
dove M è il numero di utenti serviti in modalità alta, mentre S quelli di livello basso.
Una politica bap è una coppia (C1 , C2 ) da cui si ottiene poi il resto.
Per modellare la bssc, chiamiamo δ la frequenza di connessione richiesta, λ è il tasso accettato e quindi
anche il throughput (ipotizziamo che non ci siano soppressioni, al più solo degradi). Teniamo separate
le parti bs e msc di due unità. Gli utenti totali sono N .
Chiamiamo LP la probabilità di perdita che è pari a δ−λ
δ .
Il modello di prestazione deve garantire i livelli di qualità mantenendo però un vincolo sulla perdita:
68
LP ≤ LP0 ↔ λ < δ (1 − LP0 )
In risposta ad un aumento di δ, si usa il modello per valutare se accettare più utenti (N ′ > N ) in modo
da rispettare il vincolo su LP0 . Ovvero degradando gli utenti di alto livello Avremo M ′ < M e S ′ > S ′ .
Cambieremo quindi la bap originaria (C1 + C2 ) in una bap’ (C1′ + C2′ ).
Al contrario, se c’è un decremento in δ, si alza il livello di qualità, e crescono gli utenti a livello alto, in
modo da umentare la qualità.
La stazione A modella l’allocazione dei segmenti di banda, con due parametri diversi di tassi di
servizio, η e α (job/sec a livello alto e basso). La stazione B modella, invece, le altre attività, con tasso
fisso µ. Gli additional services sono inclusi nella vacation e questi servizi sono il system tuning (bap →
bap’) ed altro. β, γ, ǫ sono altri parametri della vacation.
Nella stazione A:
1. quando arriva un job, se c’è ancora banda disponibile viene una quantità Vi di banda;
2. la bs riceve dati dal mt;
3. i dati sono inviati al msc;
4. quando un job di alto livello parte da A e va in B, la banda che si libera viene usata per l’upgrade
di un utente di basso livello.
La stazione B:
1. processa i dati (problemi di link, di routing, . . .) (non i tassi);
2. i dati trasmessi sulla rete fissa, il job se ne va;
3. se la stazione è vuota vengono eseguiti i servizi aggiuntivi, il tuning più altro.
Il throughput di A, se ci sono k job è pari a:
ρ(n) =
½
kη
M η + (k − M )α
se 0 ≤ k ≤ M
sek > M
Abbiamo ipotizzato che se un job di alto livello esce, uno basso viene promosso, per cui certamente, se
k > M , M job sono trattati a livello alto. Senza questa ipotesi, si dovrebbero distinguere i job partiti,
promossi, arrivati, . . . Il throughput medio del sistema è:
λ=
N
X
ρ(n)p(k)
k=0
69
dove p(k) è la distribuzione marginale della stazione A dovuta all’aggregazione dei diversi stati.
È stata trovata una soluzione efficiente, dato che la Q presenta una certa regolarità ed è stata espressa
la probabilità in maniera ricorsiva. Si può quindi scrivere una funzione dipendee dai throughput λ1 e λ2
(somma pesata, pregi/difetti, . . .). Ad esempio la massima soddisfazione dell’utente:
1. Supponiamo che il requisito negoziato sia quello di accogliere il maggior numero di utenti possibile,
mantenendo la probabilità di perdita al di sotto del 20%. Da questi requisiti di qualità tiriamo
job
fuori le prestazioni corrispondenti: S = 160 job
sec , LP ≥ 20% ⇒ λ ≥ δ (1 − LP0 ) ⇒ L ≥ 128 sec . Il
job
valore massimo di λ1 sarà pari a 120 sec . bap: 37 alti e 50 bassi con λ = 136.
2. Periodicamente misuriamo le reali prestazioni ed assumiamo che δ va da 160 a 180.
= 0.24 > 0.2. Usando le curve ottenute
3. Calcoliamo ora la differenza tra prestazioni: LP = 180−136
180
si nota che dobbiamo accogliere 31 a livello alto e 74 a livello basso.
4. Passiamo alla nuova bap degradando 6 utenti di alto livello. Al service provider interessa alzare la
qualità.
I requisiti sono tradotti, ci sono misurazioni e se δ aumenta si ricalcola il vincolo e si seleziona il massimo
della curva compatibile con i vincoli, si degradono degli utenti dal livello alto a quello basso.
È essenziale l’efficienza: alcuni parametri possono cambiare v1 , v2 e C. Le curve possono cambiare nel
tempo e bisogna avere un’allocazione della banda di tipo real-time.
Pertanto per risolvere il modello tramite vacation con parallelismo, bisogna risolvere una catena di Markov complessa. La Q non è risolta con forza bruta, anzi non viene presa tutta la Q, ma è viene sfruttata
la regolarità, la ripetitività a blocchi del generatore ed è stata scritta una soluzione ricorsiva. Di conseguenza abbiamo che la complessità della forza bruta è pari ad O(N 3 F 3 ) dove F cresce esponenzialmente
con h, ovvero il numero di processi nel fork/join. Mentre la complessità di questa soluzione è di O(N F 3 ).
70
A
Formulario
Deterministico
£ ¤
£ ¤
λE t2s
ρ2
=
⇒ E t2s = E 2 [ts ]
E [tw ] ⇒
2 (1 − ρ) λ
2 (1 − ρ)
E [tsrim ] =
ρE [ts ]
2
Generale
ρ2
E [tw ] =
2λ (1 − ρ)
Ã
£ ¤
£ ¤!
λE t2s
E t2s
=
E 2 [ts ]
2 (1 − ρ)
Esponenziale
£ ¤
£ ¤
λE t2s
ρ2
E [tw ] ⇒
=
⇒ E t2s = 2E 2 [ts ]
(1 − ρ) λ
2 (1 − ρ)
E [tsrim ] = ρE [ts ]
K-Erlang
E [tw ] ⇒
ρ2
2λ (1 − ρ)
µ
k+1
k
¶
=
£ ¤
¶
µ
£ ¤
λE t2s
k+1
E 2 [ts ]
⇒ E t2s =
2 (1 − ρ)
k
M/D/1
σ 2 (ts ) = 0, E [w] =
E [tw ] =
ρ (2 − ρ)
ρ2
, E [q] =
2 (1 − ρ)
2 (1 − ρ)
E [ts ] (2 − ρ)
E [ts ]
, E [tq ] =
2 (1 − ρ)
2 (1 − ρ)
M/Ek /1
σ 2 (ts ) =
E 2 [ts ]
ρ2 (k + 1)
(2 − ρ) ρ
ρ2
, E [w] =
, E [q] =
+
k
2k (1 − ρ)
2 (1 − ρ) 2k (1 − ρ)
E [tw ] =
ρ (k + 1) E [ts ]
(2 − ρ) E [ts ]
ρE [ts ]
, E [tq ] =
+
2k (1 − ρ)
2 (1 − ρ)
2k (1 − ρ)
M/M/1
σ 2 (ts ) =
E [ts ] =
1
ρ2
ρ
, E [w] =
, E [q] =
2
λ
1−ρ
1−ρ
ρE [ts ]
E [ts ]
1
, E [tw ] =
, E [tq ] =
λ
1−ρ
1−ρ
71
M/H2 /1
σ 2 (ts ) =
µ
¶
ρ2
ρ2
1
− 1 E 2 [ts ] , E [w] =
, E [q] =
+ρ
2p (1 − p)
4p (1 − p) (1 − ρ)
4p (1 − p) (1 − ρ)
E [tw ] =
ρE [ts ]
ρE [ts ]
, E [tq ] =
+ E [ts ]
4p (1 − p) (1 − ρ)
4p (1 − p) (1 − ρ)
M/G/1
¶
σ 2 (ts )
1+ 2
, E [q] = E [w] + ρ
E [w]KP
E [ts ]
µ
¶
E [w]
σ 2 (ts )
ρE [ts ]
1+ 2
E [tw ] =
=
λ
2 (1 − ρ)
E [ts ]
ρ2
=
2 (1 − ρ)
E [tq ] =
µ
E [q]
E [w] + ρ
=
= E [tw ] + E [ts ]
λ
λ
Tempo di risposta della rete rispetto al centro i
tri =
M
X
νj/i E [ts ]
j=1,i6=j
Numero di visite al centro i rispetto ad una visita al centro i
νj/i =
ηj
ηi
Relazione sulla matrice di routing
η̄ = η̄P
Tempo medio di residenza al centro j
e
E [tj ] =
E [nj ]
Xje
Lunghezza media di coda del centro j
min(Bj ,N )
E [nj ] =
X
nj pj (nj )
nj
Throughput effettivo (IS/RS-RD multiservente)
Xje = Uje µj kj
quando kj = N allora si parla di IS.
72
Throughput effettivo BBS-SO
Xje = Xj = Uje µj
dove kj è pari al numero di serventi attivi.
Utilizzazione effettiva del centro j (BBS-SO)
X
Uje =
S̄:S̄j =(nj ,dj ):nj >0∧(nj <Bi ,dj =i)
¡ ¢
π S̄
Utilizzazione effettiva del centro j (RS-RD/IS)
min(Bj ,M )
Uje
=
X
R=1
min (R, kj )
kj
X
X
sj :nj =h ∀i:ni <Bi ,pij >0
¡ ¢
π S̄ pji
dove R è il numero di job nel centro.
Probabilità marginale di lunghezza di coda o Probabilità che ci siano n job nel centro j
pj (n) =
X
S̄:nj =n
¡ ¢
π S̄
Utilizzazione per reti senza blocco
Ui =
N
X
pi (ni )
ni =1
Ui = 1 − p (0)
Throughput per reti senza blocco
Xi = Ui µi
Tempo di residenza per reti senza blocco
E [ti ] =
E [ni ]
Xi
Dimensione coda per reti senza blocco
E [ni ] =
N
X
ni p (ni )
ni =0
dove p (ni ) =
P
S̄:ni =n
π (S) è la probabilità marginale.
Tempo risposta rispetto al centro i per reti senza blocco
E [tri ] =
M
X
j=1,i6=j
73
νj/i E [ts ]
Slowdown per discipline non-preemptive senza job-size
ρ2
E [n] =
2 (1 − ρ)
µ
σ 2 (ts )
1+ 2
E (ts )
¶
£ ¤
λ2
E t2s
2 (1 − ρ)
£ 2¤
λ
E [w]
2 E ts
E [tw ] =
=
λ
1−ρ

2
λ
 E [sd (x)] = 1 + 2 E [ts ]
x(1−ρ)
2
 E [t (x)] = x + λ2 E [ts ]
£ ¤
σ 2 (ts ) = E t2s − E 2 [ts ] =
q
1−ρ
74