Sistemi Operativi 2

Esercizi Esami

Esercizi INPUT/OUTPUT
RAID LEVELS
RAID 0: non affidabile, alte prestazioni (block-level striping)
RAID 1: massima affidabilità, alto costo (block-level striping)
RAID 2: molto affidabili per via dell’ECC e hanno buona performance ma sono costosi
in overhead, prestazioni come disco singolo (bit-level striping + ECC)
RAID 3: affidabile grazie a bit parità, performance buona, per bit-level striping difficile
da sincronizzare parti meccaniche (bit-level striping unito al bit di parità)
RAID 4: alte performance ed alta ridondanza ma Il disco di parità è un bottleneck,
risorsa condivisa a cui si può accedere solo sequenzialmente ( block-level striping unito
ad un blocco di parità)
RAID 5: come RAID 4, ma dati di parità sono mantenuti distribuiti in tutti i dischi, alta
performance ma tollera 1 solo disk fault (block-level striping e un blocco di parità
distribuito)
RAID 6: come RAID 5, ma con 2 blocchi di parità per ogni stripe , tollera 2 dischi rotti
ma introduce overhead per il calcolo della parità (block-level striping)
RAID 1+0: più sistemi RAID 1 organizzati come un RAID 0. Tollera n disk fault
Es 1.1
Dati 4 dischi, calcolare MTTF orario di un’organizzazione RAID livello 0 e quello di
un’organizzazione RAID livello 1, sapendo che ogni disco i ha un tasso annuale di
fallimento λi, dove:
● λi = 0.05
● λi = 0.075
● λi = 0.25
● λi = 0.025
Non è previsto l’utilizzo di dischi hot-spare. Inoltre, una volta che un disco si guasta
non viene sostituito da uno funzionante.

RAID = Redundant Arrays of Independent Disks

MTTF = 1/𝐴𝐹𝑅
Mean Time To Failure
Average Failure Rate AFR = 0.05 + 0.075 + 0.25 + 0.025 = 0.4
1/0.4* 365day * 24h = 21900 h
Es 1.2
Un cliente vi commissiona un sistema organizzato a RAID (non specificando il livello)
specificando i seguenti requisiti
● Massimizzare capacità e prestazioni
● Affidabilità non necessaria
● Budget: $2000
Considerando solo i costi relativi all’acquisto dei dischi (escludendo quindi quelli
relativi all’acquisto di un controller RAID) e supponendo di adottare dischi da 1 TiB,
ciascuno venduto al prezzo di $400, che organizzazione RAID suggerireste al cliente
tra quelle standard (livello 0 fino a livello 6)? Motivare le risposte.

● più capacità e prestazioni significano più dischi

● affidabilità non necessaria, quindi se un disco si rompe, si rompe il sistema, ma
va bene così
● Con un budget di $2000 si possono acquistare 5 dischi da $400 per creare un
sistema RAID 0, che massimizza le prestazioni a scapito dell'affidabilità

Infatti RAID 0:

pro: alte prestazioni, specialmente per grandi richieste, perché queste possono essere
soddisfatte con operazioni parallele di lettura e scrittura e alta capacità.

contro: assenza di ridondanza comporta il fallimento dell’intero sistema RAID se solo

un disco non funziona e non è indicato per richieste “piccole”, poiché queste non
sfrutterebbero il parallelismo offerto dal RAID lv0.
Es 1.3
Un cliente vi commissiona un sistema organizzato a RAID (non specificando il livello)
specificando i seguenti requisiti
● Massimizzare affidabilità
● Nessun interesse su capacità e prestazioni
● Budget: $2000
Considerando solo i costi relativi all’acquisto dei dischi (escludendo quindi quelli
relativi all’acquisto di un controller RAID) e supponendo di adottare dischi da 1 TiB,
ciascuno venduto al prezzo di $400, che organizzazione RAID suggerireste al cliente
tra quelle standard (livello 0 fino a livello 6)? Motivare le risposte.

L'opzione migliore sarebbe RAID 1 oppure RAID 1+0, costo di 1600 per 4 dischi,
mentre il quinto disco si può utilizzare come disco di hot spare.

Infatti RAID 1:
pro: viene offerto il miglior grado di affidabilità (tollerati fino a n dischi rotti nel peggior
caso, quindi tollerati metà dei dischi guasti); Il recupero da un fallimento è rapido e
semplice; Le richieste di lettura possono essere soddisfatte al doppio della velocità
rispetto ai RAID lv0.
contro: costoso, il numero di dischi richiesti è doppio; Le prestazioni migliorano solo
marginalmente; a fronte del numero di dischi a disposizione, la capacità di
memorizzazione è comunque bassa.
Es 1.4
Un cliente vi commissiona un sistema organizzato a RAID (non specificando il livello)
specificando i seguenti requisiti
● Buon compromesso tra affidabilità e prestazioni (tolleranza ad almeno 1 disco
rotto)
● Capacità utile di almeno 4 TiB
● Budget: $2000
Considerando solo i costi relativi all’acquisto dei dischi (escludendo quindi quelli
relativi all’acquisto di un controller RAID) e supponendo di adottare dischi da 1 TiB,
ciascuno venduto al prezzo di $400, che organizzazione RAID suggerireste al cliente
tra quelle standard (livello 0 fino a livello 6)? Motivare le risposte.

Capacità utile → 4 dischi, 1 disco per gestire la parità

→ soluzione potrebbe essere RAID 4, 5, o 6 poiché 4 dischi potrebbero
gestire la capacità utile, ed un disco potrebbe gestire la parità.
→ con un RAID 5 non si ha bottleneck sul disco di parità, si
conservano i 4 dischi con 4 TiB utili e si risparmia nel budget
Es 1.5
Si supponga che un sistema utilizzi il DMA per il trasferimento di dati dal controller del
disco alla memoria principale del computer. Si assuma inoltre che l’acquisizione
dell’accesso al bus richieda t1 nsec in media e il trasferimento di una parola sul bus
richieda t2 nsec (con t1 >> t2). Dopo che la CPU ha programmato il controller DMA,
quanto tempo sarà necessario per trasferire 1000 parole dal controller del disco alla
memoria principale, se (a) è utilizzata la modalità cycle stealing (una parola alla volta)
(b) è usata la modalità burst? Si assuma che l’invio di comandi al controller del disco
richieda l’acquisizione del bus per spedire una parola e che il riscontro richieda
anch’esso l’acquisizione del bus per spedire una parola.

● Cycle stealing
1. richiede bus t1
2. trasferisce 1 parola
3. rilascia bus e attende riscontro t1
● * 1000 volte
● 1000( t2 + t1 + t1) = 2000t1 + 1000t2
● burst
1. richiede bus t1
2. trasferisce 1000 parole in blocco t2
3. richiede bus per risposta t1
● t2 + t1 + t1 = 2t1 + 1000t2
Es 1.6
Un disco ruota a 7200 RPM. Nel suo cilindro più esterno ci sono 500 settori di 512
bytes.
a) Supponendo che la testina sia già posizionata sul cilindro più esterno e all’inizio
di un settore, quanto ci si impiega a leggere un singolo settore da quel cilindro?
b) Qual è il massimo tasso di trasferimento dati (in byte/sec)?

a) 7200 giri/min = 120 giri/sec

1/RPS = 1/120 = 8.3 * 10-3 s/giro
siccome ho 500 settori facciamo 8.3 * 10-3 / 500 = 1.66 * 10-6
b) Massimo tasso di trasferimento
Tmax = dimensione traccia (tutti i settori sulla traccia) * rotational latency
dim_traccia = 500*512 = 256000 B
rot_latency = 7200/60 giri/sec = 120 giri/sec
Tmax = 256000 * 7200 / 60 = 30720000 bytes/sec ⇒ 30.72 MB/sec
Es 1.7
Si consideri un disco magnetico con 16 testine e 400 cilindri. Il disco ha 4 zone da 100
cilindri ciascuna, dove i cilindri (e quindi le tracce) di zone differenti contengono 160,
200, 240, 280 settori, rispettivamente. Si assuma che ogni settore contenga 512 byte,
che il tempo medio di seek tra cilindri adiacenti sia 1 msec, e che il disco ruoti a 7200
RPM. Calcolare:
a) la capacità del disco
b) il cylinder skew ottimale di ogni zona
c) il massimo tasso di trasferimento dati (in byte/sec) raggiungibile

sector time:
1msec == 0.001s
7200 rpm == 7200r/m * 60s/m = 120rps
0.001s/120rps = 0.000008333 = 8.3 * 10-6 s2/giro

160:
8.3 * 10-6 /160 = 0.000000052 = 5.2 * 10-8
0.001s / 5.2 * 10-8 = 19230.769230769s == 19.2msec

200:
8.3 * 10-6 /200 = 0.000000042 = 4.2 * 10-8
0.001s/4.2 * 10-8 = 23809.523809524s == 23.8msec

240:
8.3 * 10-6 /240 = 0.000000035 = 3.5 * 10-8
0.001s/3.5 * 10-8 = 28571.428571429s == 28.6msec

280:
8.3 * 10-6 /280 = 0.00000003 = 3.0 * 10-8
0.001s/3.0 * 10-8 = 33333.333333333s == 33.3msec
Max_tax = max track / latenza
traccia più lunga * latenza
max track = 280(settori della traccia più lunga) * 512 bytes =143360
latenza 60/7200 = 0.0083
tot = 143360 * 0.0083 = 1194.67

a) capacità del disco = num_settori * capacità_settore

num_settori = 160+200+240+280 = 880 settori
cap_disk = 880*512 = 450560 byte
b) cylinder skew = <seek_time>/<sector_time>
sectorTime = 60/7200 = 1/120 = 8.2*10-3
8.2*10-3/160 = 0.000052s == 0.052msec
1 msec / 0.052msec = 20
c) Tmax = <track_size> * <rotational_latency>
track_size = 280 * 512 = 143360 //si è scelto 280 dato che chiede il tasso max
rot_latency = 60/7200 = 1/120
Tmax = 143360 / 120 = 1194.666666667 B/sec
Es 1.8
Si supponga di effettuare le seguenti operazioni in sequenza su un sistema RAID 5
costituito da 5 dischi identici (inizialmente vuoti) e con blocchi (strip) da 1 byte:
1. Scrittura della sequenza di byte:
01000101, 00000110, 10110100, 11101101,
11000111, 10000101, 01110111, 01010101
 2. Lettura secondo e settimo byte di dati
3. Modifica del terzo byte di dati da 10110100 a 01001011
Per ogni punto, si illustrano le operazioni compiute dal sistema, evidenziando quante
READ e quante WRITE vengono, effettuate, e quante di queste sono fatte in parallelo.
NOTA:
● Per ognuno dei suddetti punti, il controller RAID riceve i comandi di
scrittura/lettura di byte come un’unica richiesta.
● L’ordine di scrittura sui dischi è da sinistra verso destra, dall’alto verso il basso.
● Racchiudere ogni blocco di parità tra parentesi tonde.
● Il sistema RAID non è dotato di dischi hot-spare.

0 1 2 3 4
01000101 00000110 10110100 11101101 x1
11000111 10000101 01110111 x2 01010101

x1= (01000101 00000110 10110100 11101101)xor = 00011010

x2= (11000111 10000101 01110111 01010101)xor = 01100000

x1
01000101
00000110
10110100
11101101
--------
00011010

x2
11000111
10000101
01110111
01010101
-----------
01100000
01000101
00000110
01001011
11101101
--------
11100101

10110100
01001011
00011010
------------
11100101

1) 1a stripe 2a stripe
01000101 11000111
00000110 10000101
10110100 01110111
11101101 01010101
----------- -----------
00011010 01100000

Vengono effettuate 10 scritture in parallelo a gruppi di 5

2) Per leggere il secondo ed il settimo byte di dati si possono fare due read
parallele dato che si trovano su dischi diversi. Non vi è bisogno di consultare il
blocco di parità. Quindi 2 read e 0 write.
3) Usiamo la parità sottrattiva dato che serve fare solo 2 read e 2 write, nel caso
della parità additiva in questo scenario, si dovrebbe fare un’azione in più. Leggo
il byte da modificare e il byte di parità della stripe in cui ci troviamo e scrivo il
risultato dello XOR di questi due valori e faccio lo XOR con il nuovo valore del
byte e il risultato lo si mette al posto del vecchio blocco di parità.

10110100
00011010
01001011
--------
11100101
Es 1.9
Si supponga di effettuare le seguenti operazioni in sequenza su un sistema RAID
costituito da 4 dischi identici (inizialmente vuoti), assumendo che il sistema operativo
utilizzi blocchi di dimensione 2 byte:
1. Scrittura delle sequenza di blocchi:
1[01000101] 2[00000110], 1011010011101101,
0111000111000011, 1000111110101100

-raid 0
0 1 2 3
1 [01000101 00000110] [10110100 11101101]
2 [01110001 11000011] [10001111 10101100]

-raid1
0 1
1 [01000101 00000110]
2 [10110100 11101101]
3 [01110001 11000011]
4 [10001111 10101100]
2 3
[01000101 00000110]
[10110100 11101101]
[01110001 11000011]
[10001111 10101100]

2. Lettura del secondo e del quarto blocco

3. Modifica del primo e del terzo blocco in:
1011101001001011, 1000111000111100
Spiegare come vengono effettuate le suddette operazioni utilizzando le seguenti
organizzazioni RAID:
a) RAID di livello 0 con strip da 1 byte
b) RAID di livello 1 con blocchi da 1 byte
Per ogni punto, si illustrano le operazioni compiute dal sistema, evidenziando quante
READ e quante WRITE vengono effettuate, e quante di queste sono fatte in parallelo.
NOTA:
● Per ognuno dei suddetti punti, il controller RAID riceve i comandi di
scrittura/lettura di byte come un'unica richiesta
● L'ordine di scrittura sui dischi è da sinistra verso destra, dall'alto verso il basso
● Racchiudere ogni blocco di parità tra parentesi tonde
● Il sistema RAID non è dotato di dischi hot-spare.

1) 8 scritture, 4 in parallelo
2) 4 letture, 2 in parallelo
3) 4 write, 2 in parallelo
2) Lettura blocco 2, 4: 4 letture, 4 in parallelo in gruppo da 2
Es 1.10
Si consideri un sistema RAID di livello 4 composto da N dischi (dove N comprende il
disco di parità e quindi N>1) a cui arriva una richiesta di scrittura per B blocchi che
interessa una sola stripe (quindi B < N). Determinare il valore di B per cui risulti più
efficiente (in termini di numero totale di operazioni di I/O su disco) usare il metodo della
parità additiva piuttosto che quello della parità sottrattiva.

N-1 = dischi disponibili

B = num byte modificati
(N-1-B) = numero di read che dobbiamo fare dato che è additivo
(B+1) = num di write che dobbiamo fare

parità additiva:
(N-1-B)+(B+1) = N == Wadd

B+1+B+1 = 2B+2 == Wsotr

conviene quella additiva quando Wadd < Wsotr

N < 2B + 2 = (N-2)/2 < B

Es 1.11
Al driver del disco arrivano, nell'ordine specificato, le richieste di cilindri 11, 23, 21, 3,
41, 7, e 39. Ogni operazione di seek tra due cilindri consecutivi (track-to-track seek
time) impiega 6 msec. Specificare l'ordine di visita dei vari cilindri e il tempo totale di
seek che si ottengono utilizzando i seguenti algoritmi:
a) First-Come, First-Served (FCFS)
b) Shortest-Seek First (SSF)
31, 39, 41, 23, 21, 11, 7, 3
(|31-39|+|39-41|+|41-23|+|23-21|+|21-11|+|11-7|+|7-3|)* 6 msec =

( 8 + 2 + 18 + 2 + 10 + 4 + 4) = 48 * 6 = 288 msec

c) LOOK
31
11, 23, 21, 3, 41, 7, 39 → | 3, 7, 11, 21, 23, 31, 39, 41
d) C-LOOK
In tutti i casi, il braccio del disco è inizialmente posizionato sul cilindro 31. Per gli
algoritmi LOOK e varianti, la direzione iniziale è DOWN.

a) FCFS

(|31-11|+|11-23|+|23-21|+|21-3|+|3-41|+|41-7|+|7-39|)* 6 msec =
= (20+12+2 +18+38+34+32) * 6 msec = 156 * 6 = 936 ms

b) SSF

(|31-23|+|23-21|+|21-11|+|11-7|+|7-3|+|3-39|+|39-41|)* 6 msec =
= (8 +2 +10+4 +4 +36+2 ) * 6 msec = 66 * 6 = 396 ms

c) LOOK

(|31-23|+|23-21|+|21-11|+|11-7|+|7-3|+|3-39|+|39-41|)* 6 msec =
= (8 +2 +10+4 +4 +36+2 ) * 6 msec = 66 * 6 = 396 ms
 d) C-LOOK

(|31-23|+|23-21|+|21-11|+|11-7|+|7-3|+|3-41|+|41-39|)* 6 msec =
= (8 +2 +10+4 +4 +38+2 ) * 6 msec = 68 * 6 = 408 ms
Es 1.12
Un processo richiede l'utilizzo della CPU ogni 0.5 sec. Si supponga che la CPU
risponda immediatamente alla richiesta e impieghi 100 msec per processarla. Inoltre,
sia P W il consumo elettrico della CPU e si supponga che il consumo elettrico della
CPU in stato idle sia nullo (cioè, il consumo elettrico statico è zero). Rispondere alle
seguenti domande:
a) Se il voltaggio V della CPU è ridotto a V/n, qual è il valore ottimale di n?
n = 0.5 / 0.1 = 5

b) Qual è il risparmio energetico che si ottiene in 1 sec, riducendo il voltaggio della

CPU come al punto (a) rispetto a non ridurlo?
Enocut = Po * Tproc + Ps * (tTot - Tproc ) = pw * 0.1 + 0 * 0.4 = 0.1J(watt al
secondo)
𝑃
Ecut = ( 20 * tTot) + PS * (tTot - tTot) = (PW/52 * 0.5) + 0*(0) = PW/25 * 0.5 =
𝑛
0.02 P J

Ediff = Enocut - Ecut = 0.1 - 0.02 = 0.08 P J

Epercentuale = 100 * Edif / Enocut = 8 / 0.1 = 80%

f = 1/0.5 = 2 Hz
Tproc = 0.1 s
Ps = 0
Po = P W
tTot = 0.5 sec

a) Tproc * n = tTot ⇒ n = tTot / Tproc ⇒ 0.5/0.1 = 5

b) ENoCut = P0 * Tproc + Ps * (tTot - Tproc) =
= PW * 0.1 + 0 * 0.4 = 0.1 PW + 0 = 0.1 P J (Watt al secondo = Juole)

ECut = P0 / n2 * tTot + Ps * (tTot - tTot) =

= PW/52 * 0.5 + 0 * 0 =
= PW/25 * 0.5 = 0.02 P J
 Edif = ENC - EC =
= 0.1PW - 0.02 PW = 0.08 PW
Epercentuale = 100 * Edif / ENoCut =
= 100 * 0.08 PW / 0.1 PW = 80%

Es 1.13
Un processo richiede l'utilizzo della CPU ogni 0.5 sec. Si supponga che la CPU
risponda immediatamente alla richiesta e impieghi 100 msec per processarla. Inoltre, si
supponga che il consumo elettrico statico della CPU sia PS = 30 W e quello dinamico
sia PD = 10 W. Rispondere alle seguenti domande:
a) Si supponga di voler ridurre il voltaggio V della CPU a V/n, qual è il valore
ottimale di n?
b) Qual è il risparmio energetico che si ottiene in 1 sec, riducendo il voltaggio della
CPU come al punto (a) rispetto a non ridurlo?

a) Tproc * n = tTot ⇒ n = tTot / Tproc ⇒ 0.5/0.1 = 5 //valore

ottimale di n sono le volte la cpu riesce a processare un
processo prima che arrivi un’altra richiesta.
b) ENoCut = PD * Tproc + Ps * (tTot - Tproc) =
= 10 * 0.1 + 30 * 0.4 = 13 J (Watt al secondo = Juole)

ECut = PD / n2 * tTot + Ps * (tTot - tTot) =

= 10/52 * 0.5 + 30 * 0 = 0,2 J

Edif = ENC - EC = 12,8 J

Epercentuale = 100 * Edif / ENoCut =
= 100 * 12,8 J / 13 j = 98%
Es 1.14
Si supponga di voler attuare una politica di risparmio del consumo energetico basata
sull’utilizzo del disco tale per cui in base a una stima TEST dell’arrivo della prossima
richiesta di utilizzo del disco si decide se lasciare i suoi piatti in movimento (stato
“active”) o arrestarne la rotazione (stato “sleep”). In particolare, si consideri un disco
con le seguenti caratteristiche:
● consumo elettrico nello stato “active” PW = 6 Watt
● consumo elettrico nello stato “sleep” PS = 2 Watt
● tempo per passare da “active” a “sleep” Tsd = 10 sec
● energia elettrica consumata nel passaggio da “active” a “sleep” Esd = 26 Joule
● tempo per passare “sleep” a “active” Twu = 5 sec
● energia elettrica consumata nel passaggio da “sleep” a “active” Ewu = 60 Joule
Calcolare il valore Td = tale per cui TEST > Td diventi vantaggioso porre il disco da
“active” a “sleep”

TEST > 14 sec, diventa vantaggioso porre il disco a “sleep”

Es 1.15
Si considerino le seguenti situazioni e indicare quali rappresentano interrupt precisi e
quali interrupt imprecisi. Il simbolo PC denota il Program Counter. L’ordine delle
istruzioni va dal basso verso l’alto. Motivare le risposte.

Regole:
1) PC è salvato in un posto conosciuto
2) tutte le istruzioni eseguite prima di quella puntata dal PC sono state
completamente eseguite
3) nessuna istruzione oltre a quella puntata dal PC è stata eseguita
4) lo stato di esecuzione dell’istruzione puntata dal PC è conosciuto

a)
|----------------|
| 30% executed | 312
|----------------|
| Not executed | 308
|----------------|
PC→ | Fully executed | 304
|----------------|
| Fully executed | 300
|----------------|

Preciso: le istruzioni dopo PC non sono state

completate e quelle prima sono state completate
b)
|----------------|
| 30% executed | 312
|----------------|
| Not executed | 308
|----------------|
PC → | Not executed | 304
|----------------|
| Fully executed | 300
|----------------|

Preciso: le istruzioni dopo PC non sono state

completate e quelle prima sono state completate

c)
|----------------|
| Not executed | 312
|----------------|
| Not executed | 308
|----------------|
PC → | Not executed | 304
|----------------|
| 90% executed | 300
|----------------|

Impreciso: le istruzioni prima non sono state

completate

d)
|----------------|
| Fully executed | 312
|----------------|
| Fully executed | 308
|----------------|
PC → | 90% executed | 304
|----------------|
| Fully executed | 300
|----------------|

Impreciso: le istruzioni dopo sono state completate

Es 1.16
Si consideri uno schema di indirizzamento CHS in cui sono utilizzati 14 bit per il numero
di cilindri, 5 bit per il numero di testine, e 11 bit per il numero di settori.
Si converta l’indirizzo LBA 248209144 in notazione CHS (C,H,S)

chs = (3787,12, 1785)

Es 1.17
Si consideri un disco caratterizzato da una velocità rotazionale pari a 10000 RPM, un
tempo medio di seek pari a 5 msec, un numero medio di settori per traccia pari a 500
Determinare:
● Latenza rotazionale media
● Tempo medio di trasferimento
● Tempo medio di posizionamento
● Tempo medio di accesso a un settore
I risultati devono essere espressi in msec.
10000 RPM = 10000/60 = 166.6 RPS
Lat rot max = 1/RPS*1000 = 1/166.6*1000 = 6 msec
//1000ms per avere il risultato in msec
Lat rot media = 6/2 = 3 msec
T medio trasf = Lat rot max / n medio settori per traccia
= 6 / 500 = 0,012 msec
T medio acc = medio seek + Lat rot media + medio trasf
= 5 + 3 + 0,012 = 8,012 msec
Es 1.18
Si calcoli il valore del sector interleaving per un disco caratterizzato da una velocità
rotazionale pari a 10000 RPM, un numero di settori per traccia part a 1500, e un tempo
di trasferimento di un settore in memoria (incluso il tempo di controllo dell’ECC) pari a
40 microsec.

10000 RPM = 10000/60 = 166,6 RPS

Latenza rotazione massima = 1/RPS = 1/166,6 = 6msec
Tempo di passaggio settore = Latenza rotazione massima / numero settori per traccia =
6 / 1500 = 4 microsec
Sector interleaving = tempo di trasferimento di un settore in memoria/Tempo di
passaggio settore = 40 / 4 = 10 settori
Esercizi FILE SYSTEMS
Es 2.1
Si consideri il seguente albero di directory:

Si supponga che si voglia accedere al file foo.txt e che la directory corrente sia “/a/d”
Dati i seguenti path:
a) /a/b/c/foo/txt
i) non valido
b) ./foo.txt
i) /a/d/./foo.txt
ii) non valido
c) /b/../a/c/foo.txt
i) valido
ii) absolute
d) /a/c/foo.txt
i) valido
ii) canonical
e) /a/c/./foo.txt
i) valido
ii) absolute
 f) ../c/foo.txt
i) valido
ii) relativo
g) /b/../a/../b/../a/d/../c/foo.txt
i) valido
ii) assoluto
h) ../../a/c/foo.txt
i) valido
ii) assoluto
Rispondere alle seguenti domande:
1. Quali dei suddetti path sono validi?
2. Quali tra i path validi sono assoluti, relativi, o canonici?
● ASSOLUTO - parte dal root e usa “.” e “..”
● CANONICO - diretto, da root a file, senza “.” e “..”
● RELATIVO - parte dalla directory corrente con “.” e “..”
Es 2.2
Si consideri un file system installato su un disco da 1TiB. Si supponga che il file system
utilizzi blocchi di 2 KiB e indirizzi a blocchi a 64 bit, e si consideri un file “foo.txt” cui
sono stati allocati i seguenti blocchi di dati (elencati in ordine di allocazione): 1080,
1081, 1082, 7400, 7401, 7407, 12510, 22418, 22419, 22420, 23710, 1079.
a) Si disegni la struttura dati utilizzata per tenere traccia di tali blocchi nei seguenti
casi:
i) Allocazione basata su lista concatenata di blocchi
ii) Allocazione basata su lista concatenata con File Allocation Table (FAT; si
usi -1 come codice di terminazione di lista)
iii) Allocazione indicizzata basata su i-node con 4 blocchi diretti, 1 puntatore
indiretto singolo e 1 puntatore indiretto doppio (si usi -1 per indicare un
campo della struttura non utilizzato). Il blocco contenente l’i-node ha
indirizzo 512.
b) Si dica qual è la dimensione massima di un file nei tre casi del punto (a)
c) Si dica quali informazioni occorre memorizzare nella entry di directory nei file nei
tre casi del punto (a)

spazio totale meno i puntatori -> 2^40 / 2^11

A = S*B
S = N + sum(Li)
Es 2.3
Si consideri la procedura fsck per la verifica della consistenza nei file system Unix e si
esamini il contenuto delle seguenti tabelle:

Si indichi quali sono le situazioni di inconsistenza (se ce ne sono) e, per ognuna di esse,
si dica come fsck riporta il file system in uno stato consistente. Si assuma che il file
system tenga traccia dei blocchi liberi tramite una lista concatenata.

1) blocco 1 = blocchi liberi duplicati

a) fsck ricostruisce la free-blocks list in modo da rimuovere i duplicati
2) blocco 5 = blocchi usati duplicati
a) fsck alloca 3-1 = 2 blocchi, vi copia il contenuto dei blocchi duplicati ed
alloca una delle copie del blocco duplicato ad ogni file a cui quel blocco è
associato, poi avverte l’utente dell’errore
i) abbiamo un contatore che indica il numero di spazi di blocchi che
viene decrementato e poi viene ricreata nuovamente la lista (3-1)
ii) poi vengono create tante copie dei blocchi duplicati, quanti sono i
file in uso -1 (3-1)
iii) poi viene re-incrementato il contatore
iv) se i contatori hanno tutte e due 1, se ne decrementa uno dei due e
avverte l’utente dell’errore
3) blocco 9 = blocchi mancanti
a) fsck aggiunge quei blocchi mancanti alla struttura dati free-blocks
Es 2.4
Si consideri la cache di un file system che utilizza la tecnica di hashing per velocizzare il
reperimento dei blocchi in essa presenti, e la politica LRU per il rimpiazzamento dei
blocchi. Si ipotizzi inoltre che tale cache preveda l’uso di 8 “slot” per la tabella di hash,
indirizzati da 0 a 7, e che la funzione di hashing utilizzata sia h(B) = B mod 8, dove B è
l’indirizzo del blocco da memorizzare nella cache.
a) Si disegni lo stato della cache dopo l’inserimento dei seguenti blocchi: 4, 20, 44,
244, 9,17,41, 57, 159, 231
b) Partendo dal punto precedente, si disegni lo stato della cache dopo
l’inserimento del blocco 347
Si supponga che:
● la dimensione massima della cache sia di 10 blocchi
● l’ordine di arrivo dei blocchi sia da sinistra verso destra (as es., nel punto (a), il
primo blocco ad arrivare è il blocco 4
● la cache sia inizialmente vuota
Nei diagrammi, indicare quale elemento rappresenta l’elemento LRU e quale quello
MRU

a) 4, 20, 44, 244, 9,17,41, 57, 159, 231

h(4) = 4 mod 8 = 4
h(20) = 20 mod 8 = 4
h(44) = 44 mod 8 = 4
h(244) = 244 mod 8 = 4
h(9) = 9 mod 8 = 1
h(17) = 17 mod 8 = 1
h(41) = 41 mod 8 = 1
h(57) = 57 mod 8 =1
h(159) = 159 mod 8 = 7
h(231) = 231 mod 8 = 7

LRU → 4, 20, 44, 244, 9,17,41, 57, 159, 231 ← MRU

b) LRU → 4, 20, 44, 244, 9,17,41, 57, 159, 231, 347 ← MRU
h(347) = 347 mod 8 = 3
Es 2.5
Si consideri un disco di 512 GiB e un file system installato su di esso che impieghi gli i-
node come metodo di allocazione di blocchi ai file e una bitmap per la gestione dei
blocchi liberi.
Supponendo di utilizzare blocchi di 4 KiB ed indirizzi a 32 bit, si risponda alle seguenti
domande:
a) Qual è la dimensione massima di un file in tale file system se gli i-node
includono 16 puntatori diretti, un puntatore indiretto singolo, 2 puntatori
indiretti doppi e 2 puntatori indiretti tripli?
b) Qual è la dimensione della bitmap per la gestione dei blocchi liberi? Per
semplicità, si assuma che l’intero disco possa essere utilizzato per memorizzare
blocchi di dati

a) N = indirizzi diretti = 16
M = indirizzi indiretti = 1 * 21, 2 * 22, 2 * 23
L = numero indirizzi creabili = 4 KiB/ 32 bit → 212 / 22 = 1024 ==
210
DimMaxFile = S * B
S = N + sum(Li) con i che va da 1 a M
S = 16 + 1*10241 + 2*10242 + 2*10243
S = 16 + 1024 + 2097152 + 2147483648
S = 2149581840
DimMaxFil = 2149581840 * 4 KiB = 8598327360 KiB

SPIEGATO PIU SEMPLICE

dim max file = 4KiB * (16 + 1*10241 + 2*10242 + 2*10243 )

b) numero blocchi = dim_disco / dim_blocco =

1 GiB = 230 B
512 == 29
4 KiB = 212
230 B * 29 / 212 = 239 / 212 = 227 blocchi
dim_bitmap = 227 bit/ 23 → 224 B = 16 MiB
● si usa 23 perché i-node hanno spazio di indirizzi = 23
Es 2.6
Si vuole formattare un disco da 512 GiB con un particolare file system usando blocchi
da 4 KiB. Determinare quali delle seguenti scelte progettuali sono valide per
rappresentare tutti i blocchi del disco:
a) Indirizzi di blocchi a 64 bit
b) Indirizzi di blocchi a 16 bit
Limitandosi alle scelte progettuali corrette e supponendo di dover memorizzare un file
composto da 32 KiB di dati, determinare overhead e spazio sprecato nel caso si utilizzi:
c) l’allocazione basata su FAT
d) l’allocazione indicizzata con blocco indice da 4 KiB
e) l’allocazione basata su lista concatenata con cluster da 16 KiB

D = Dimensione Partizione Disco = 512 GiB == 239 B

B = Dim Blocco = 4 KiB = 22 * 210 = 212 B
F = Grandezza File = 32 KiB = 215 B
P1 = Dim Puntatore blocco = 64 bit == 23 B
P2 = 16 bit == 2 B
numero_blocchi = D / B = 512 GiB / 4 KiB = 29 * 230 / 212 = 239 / 212 = 227 blocchi

a) con 64 sufficienti poiché ho 264 blocchi indirizzabili, abbiamo 227 blocchi nel Hard
Disk da 512 GiB
b) con 16 non sufficienti perché abbiamo solo 216 indirizzabili, non riesco a
indirizzare tutti e 227 blocchi
c) FAT
D = Dimensione Partizione Disco = 512 GiB == 239 B
B = Dim Blocco = 4 KiB = 22 * 210 = 212 B
F = Grandezza File = 32 KiB = 215 B
P1 = Dim Puntatore blocco = 64 bit == 23 B

lunghezza FAT M = D/B = 239 / 212 = 227 blocchi

dimensione FAT S = M*P = 227 * 23 = 230
num blocchi allocati per il file N = F/B = 215 / 212 = 23
Overhead % = S / D = 230 / 239 = 2-9 ⇒ 0.002 *100 = 0.2%
wasted % = ( 1 - ( F / (N*B))) = ( 1 - (2!" / (2# ∗ 2!$ ))) = 1 - 1 = 0%

𝐹 1
= 𝐹 ∗ = 𝐹/𝐹 = 1
(𝐹/𝐵) ∗ 𝐵 𝐹
 d) Index

D = Dimensione Partizione Disco = 512 GiB == 239 B

B = Dim Blocco = 4 KiB = 22 * 210 = 212 B
F = Grandezza File = 32 KiB = 215 B
P1 = Dim Puntatore blocco = 64 bit == 23 B
blocco indice = 4 KiB
I = num disk blocks allocated to index blocks = 1 (B / index block size) = 212 / 212
Index-block size S = I*B = 1 * 212 = 212
numero blocchi allocati solo per i dati M = F / B = 215 / 212 = 23 = 8 blocchi
num blocchi allocati per file N = I + M = 1 + 8 = 9 blocchi
Overhead % = I/N = 1/9 * 100 = 11%
Wasted % = ( 1 - (P * M+ F) / (N*B)) = ( 1 - (23 * 23 +215) / (9 * 212) =
= (1 - (26 + 215) / (9 * 212) =
= (1 - (26 + 215) / ((1 + 23) * 212) =
= (1 - (26 + 215) / (212 + 215))
= 1 - (32832 / 36864) = 0.109375 *100 = 11%
e) Cluster

B = Dim Blocco = 4 KiB = 22 * 210 = 212 B

F = Grandezza File = 32 KiB = 215 B
P1 = Dim Puntatore blocco = 64 bit == 23 B
cluster da 16 KiB = 214
C = numeri di blocchi per cluster = 16 KiB / B = 4 = 22
numero cluster allocati M = F / (C*B-P) = 215 / ( 22 * 212 - 23) = 2
numero blocchi allocati N = M * C = 2 * 4 = 8 blocchi
Overhead % = P / C*B = 23 / 214 = 0.0005 *100 = 0.05%
Wasted % = ( 1 - (P * M+ F) / ( N * B )) = 1- (24+215) / 215 = 1 - 1.0005 ~~~ 0%
= 1 - (24 + 215) / (23 * 212)
= 1 - 1.000488281 = −0.000488281 ~~~ 0%
Es 2.7
Si consideri un file system inizialmente composto dai file F1, F2, F3, F4. Si applichino le
tecniche di backup differenziale e incrementale al seguente esempio, supponendo che
si esegua il backup totale ogni 3 giorni a partire dal Giorno 0 e che ogni backup totale
contenga tutti i file modificati dal giorno 0 sino al giorno della sua esecuzione:
a) Backup differenziale

Giorni 0 1 2 3 4 5 6 7

File cambiati F1, F2, F1, F5 F5 F6,F1 F2, F3, F7

F3, F4 F10

Tipo Backup Full diff diff diff full diff diff diff

File inclusi 1, 2, 3, x 1, 5 1, 5 1, 2, 3, 2, 3, 2, 3, 2, 3, 7,
nel backup 4 4, 5, 6 10, 10 10

b) Backup incrementale

Giorni 0 1 2 3 4 5 6 7

File cambiati F1, F2, F1, F5 F5 F6,F1 F2, F3, F7

F3, F4 F10

Tipo Backup full incr incr incr full incr incr incr

File inclusi 1, 2, 3, x 1, 5 5 1, 2, 3, 2, 3, x 7
nel backup 4 4, 5, 6 10

c) Ripristino dei file al giorno 5 nella situazione del punto (a)

i) scarica l’ultimo full-backup (4), poi scarica tutto il backup del giorno
desiderato, sovrascrivendo i file cambiati
d) Ripristino dei file al giorno 5 nella situazione del punto (b)
i) scarica l’ultimo full-backup (4), poi scarica di tutti i giorni fino al giorno
desiderato
Per la riga “Tipo Backup” si utilizzi “F” per “full-backup”, “D” per “backup differenziale e
“I” per “backup incrementale”
Es 2.8
Si consideri il seguente file system, dove i quadrati rappresentano delle directory, i
cerchi rappresentano dei file, i numeri all'interno delle forme rappresentano i numeri
degli i-node e le forme colorate di grigio rappresentano delle modifiche, e si applichi
l'algoritmo dump di UNIX per il dump logico

Per ogni fase dell’algoritmo dump si utilizzi una tabella separata con due righe, la
prima contenente i numeri di i-node e la seconda contenente lo stato di marcatura
degli i-node alla fine della fase (una X, indica un i-node marcato; nulla, indica un i-node
non marcato).

1 2 3 4 5 6 7 8 9 10 11 12 13

fase x x x x x x x x x x
1

fase x x x x x x x x x
2

fase x x x x
3

fase
4
● Fase 1: marchio tutti i file modificati e tutte le directories (marchio tutti tranne
pallini bianchi)
● Fase 2: marchio tutto tranne fase 1, e le directories che contengono solo pallini
bianchi
● Fase 3: demarchio tutte le directories, lasciando marcati solo i file modificati,
ossia i pallini grigi
● Fase 4: demarchio tutto
Es 2.9
Si supponga che in un file system UNIX basato su i-node, due utenti Alice e Bob
vogliano condividere i file “/home/bob/foo” (il cui i-node ha numero 123) e
“/home/bob/bar” (il cui i-node ha numero 456), entrambi posseduti da Bob. Si
considerino I seguenti casi:
a) La condivisione è effettuata esclusivamente tramite hard-link
b) La condivisione è effettuata esclusivamente tramite symbolic-link
e per ognuno di essi, si considerino le seguenti operazioni fatte in sequenza:
1. Alice crea un link “/home/alice/foo.lnk” al file “/home/bob/foo” e un link
“/home/alice/bar.lnk” al file “/home/bob/bar”
2. Bob cancella “/home/bob/foo”
3. Alice sposta il file “/home/alice/bar.lnk” in “/home/alice/stuff/bar.lnk”
Per ognuno dei casi (a) e (b) suddetti, si mostrino le informazioni associate ai 4 file al
termine di ogni operazione, indicando per ogni file le seguenti informazioni:
● numero i-node del file
● l’utente proprietario dell’i-node
● il valore del campo link-counter dell’i-node
● se il file rappresenta un link, dire se il link è valido, cioè se permette di
raggiungere il file collegato
Se un file è stato cancellato, indicare comunque le informazioni dell’i-node a cui il file
era associato.
In tutti i casi, si supponga che:
● inizialmente il link-counter negli i-node di “/home/bob/foo” e “/home/bob/bar”
sia pari a 1
● nel caso in cui occorra allocare nuovi i-node per i link, il sistema operativo li
scelga fra i seguenti i-nodi liberi: [100, 150, 200, 250, 300, 350, 400]
Es 2.10
Quali e quante operazioni su disco sono necessarie per recuperare l'i-node per un file
con nome di percorso /home/foo/docs/thesis.doc?
Si assuma che l'i-node per la directory root sia il numero 1 e che si trovi già in memoria,
e che nessun altro i-node relativo allo stesso path si trovi in memoria. Inoltre si assuma
che ogni directory occupi in un unico blocco di disco. Per i numeri di i-node (escluso
quello per la root directory) e indirizzi di blocchi, si utilizzino valori arbitrari.
Esercizi VIRTUALIZZAZIONE
Es 3.1
Nell’ambito della virtualizzazione, si consideri la tecnica nota come shadow paging. Si
supponga che su uno stesso computer siano in esecuzione due diverse macchine
virtuali (VM1 e VM2), su ciascuna delle quali è in esecuzione la stessa applicazione
(corrispondente a due distinti processi, denominati entrambi P1), come raffigurato nella
figura sottostante. Si riportino le shadow page table dei due processi in questione.
soluzione: