Skip to content
Snippets Groups Projects
Commit f60fff9f authored by Gianluca's avatar Gianluca
Browse files

upd

parent 2bb19d03
No related branches found
No related tags found
No related merge requests found
# Formulario Sistemi Operativi 2
## LBA e CHS:
> Sempre arrotondare per difetto.
### Da LBA a CHS:
1. Elevare in potenze di due i bit forniti, $2^{\text{Bit Forniti}}$;
2. Calcolare C, H ed S con le seguenti formule:
$C = LBA/(\text{Num Settori} * \text{Num Testine})$
$H = (LBA/\text{Num Settori})\text{ mod Num Testine}$
$S = (LBA \text{ mod Num Settori}) +1$
### Da CHS a LBA:
1. Elevare in potenze di due i bit forniti, $2^{\text{Bit Forniti}}$;
2. Calcolare LBA con la seguente formula:
$LBA = (C* \text{Num Testine +} H) * \text{Num Settori} +(S-1)$;
---
## Cylinder Skew:
> Sempre arrontondamento per eccesso.
1. Calcolare latenza rotazionale max [secondi]: $60/RPM$;
2. Calcolare tempo su singolo settore [secondi]: $\text{Latenza Rotazionale Max} * \text{Numero Settori per Traccia}$
3. Calcolare il Cylinder Skew [settori]: $\text{Tempo Seek} / \text{Tempo singolo settore}$
---
## Capacità del disco:
Capacità del disco [bytes]:
$\text{N Testine} * \text{N Cilindri} * \text{N Settori} * \text{Dim Settore}$
---
## Sector Interleaving:
1. Calcolare la latenza rotazionale max [secondi]: $60/RPM$
2. Calcolare il tempo sul singolo settore [secondi]: $\text{Lat Rot Max} / \text{Num Settori per traccia}$;
3. Calcolare il sector interleaving [settori]:
$\text{Tempo Transferimento dati} / \text{Tempo singolo settore}$
---
### Tasso Trasferimento:
Tasso Trasferimento [Byte/secondo]:
$\text{Num Settore per traccia} * \text{Dimensione Settore in Byte} * (\text{RPM}/\text{60 Secondi})$
---
## Ordine Visita Cilindri:
Ricordati che il LOOK fa _due passate_, invece C-LOOK torna immediatamente all'inizio/fine senza visitare i cilindri.
Numero totale di cilindri [cilindri]: $|\text{Cil}_1 - \text{Cil}_2|+|\text{Cil}_2 - \text{Cil}_3| ...
$
Seek Time [secondi]: $\text{Num tot cilindri} * \text{Tempo operazione di seek}$;
---
## RAID:
### RAID 3:
Due tipe di parità possibile:
- Even Parity: il numero di bit ad 1 deve essere pari;
- Odd Parity: il numero di bit ad 1 deve essere dispari.
### RAID 4 e 5:
**Additive Parity (RAID 4 e 5):**
Additive Parity: $\text{Old Strip}_0 \oplus \text{Old Strip}_1 \oplus \text{New Strip}_2 \oplus ...$
Fai XOR tra tutte le strip non modificate + XOR con strip nuova, il risultato è la parity strip.
**Subtrative Parity (RAID 4 e 5):**
Subtractive Parity: $\text{Old Strip}_0 \oplus \text{New Strip}_0 \oplus \text{Old Parity Strip}$
Fai XOR dei valori vecchi delle strip che stanno per essere modificate con i valori nuovi delle strip, in più ci aggiungi la vecchia parity, il risultato è la nuova parity strip.
**Trovare il punto di pareggio (RAID 4 e 5):**
Sappiamo che:
- $\text{Parità Additiva} = (n-1)-B$, dove $B$ sono le strip modificate;
- $\text{Parità Sottrattiva} = B +1$
Il Crossover point è dato da:
$\text{Parità Additiva} = \text{Parita Sottrattiva}$
$(n-1)-B = B + 1$
$2B = n-2$, che diventa $B = (n-2)/2$.
Se le strip modificate sono $> (n-2)/2$ allora conviene usare la parità additiva, se invece è $<$ allora conviene la sottrattiva. Se sono uguali è indifferente.
In entrambi i casi il numero di WRITE rimane lo stesso, cambia soltanto il numero di READ.
**Ricavare una strip danneggiata:**
Usi la additive parity con anche il valore della parity strip, quello che ottiene è il valore della strip danneggiata.
### RAID 6:
Usa due dischi per la parità, il resto è identico.
---
## Risparmio Energetico:
### Hard Disk:
1. Calcolare $T_d$ [secondi]:
$T_d = (E_{sd} + E_{wu}-P_s*(T_{wu}+T_{sd}))/(P_w-P_s)$
2. Controllare se:
1. $T_u < T_d$ allora conviene passare dallo stato ASLEEP allo stato AWAKE;
2. $T_u > T_d$ allora conviene passare dallo stato AWAKE lo stato ASLEEP;
3. se uguali indifferente.
## File Systems:
### Lista Concatenata:
1. Converti tutti i dati in potenze di due, ricordandoti di trasformare eventuali bit in byte;
2. Calcolare il numero di puntatori in un blocco [bytes]: $\text{Dim Partizione} / \text{Dim Blocco}$;
3. Calcolare lo spazio effettivo [bytes]: $\text{Dim Partizione} - \text{Numero puntatori}$.
Se viene richiesto Overhead e Wasted Space continua sotto.
4. Calcolare Dimensione dati dentro blocco [bytes]: $\text{Dim blocchi}- \text{Dim Puntatore}$;
5. Calcolare Numero di nodi necessari per salvare il file F [blocchi]: $F/\text{Dim Dati dentro blocco}$;
6. Calcolare Wasted Space [bytes]: $(\text{Dim Dati dentro blocco} * \text{Numero nodi necessari})-\text{File }F$;
7. Calcolare Wasted Space [percentuale]:
$(\text{Wasted Space in Bytes}/(\text{Dim Dati dentro blocco * numero nodi necessari}))*100$
8. Calcolare l'overhead [percentuale]: $(\text{Dim Puntatori}/(\text{Dim Blocco}*\text{Num Blocchi} )) * 100$;
### FAT:
1. Converti tutti i dati in potenze di due, ricordandoti di trasformare eventuali bit in byte;
2. Calcolare il numero di entries FAT [bytes]: $\text{Dim Partizione} / \text{Dim Blocco}$;
3. Calcolare la dimensione della FAT [bytes]: $\text{Numero di Entries Fat} * \text{Dim Puntatore}$;
4. Calcolare la dimensione massima di un file [bytes]: $\text{Dim Partizione} - \text{Dim Fat}$,
se l'esercizio richiede la dimensione di un file in blocchi allora fai:
$\frac{\text{Dim Partizione}}{\text{Dim Blocco}}-\frac{\text{Dim Fat}}{\text{Dim Blocco}}$
Se viene richiesto Overhead e Wasted Space continua sotto.
5. Wasted Space [bytes]: $\text{Dim Fat}-\text{Dim File F}$
6. Wasted Space [percentuale]: $(\text{Wasted Space in Bytes}/\text{Dim Partizione}) * 100$
### I-Node:
1. Converti tutti i dati in potenze di due, ricordandoti di trasformare eventuali bit in byte;
2. Calcolare il numero di puntatori I-Node in un blocco [bytes]: $\text{Dim Blocco} / \text{Dim Puntatore}$;
3. Calcolare la Dim File Possibile [bytes]:
$(\text{Num Puntatori Diretti} + \text{Num Puntatori in un blocco} + \text{Num Puntatori in un blocco}^2 ...) * \text{Dim Blocco}$
La formula cambia in base a quanti puntatori indirtti ci sono, per esempio se c'è solo un puntatore indiretto singolo ti fermi a $\text{Num Puntatori in un blocco}$, sennò vai avanti, se è triplo aggiungi $+ \text{Num Puntatori in un blocco}^3$.
Se l'esercizio richiede la dimensione in blocchi allora fai il risultato del punto 3 diviso $\text{Dim Blocco}$.
---
## FSCK:
### Consistenza blocchi:
> 2 tabelle, in uso e liberi
- Entrambi 0 = missing block, FSCK lo assegna alla struttura dati dei blocchi liberi e aggiorna il contatore
- Entrambi 1 = blocco sia in uso che libero, FSCK può scegliere se rimuoverlo dai blocchi allocati o dai blocchi liberi
- Valore > 1 nei blocchi liberi = Blocco libero duplicato, FSCK ricostruisce la struttura dati dei blocchi liberi e aggiorna il contatore
- Valore > 1 nei blocchi in uso = Blocco in uso duplicato, è l’inconsistenza peggiore, FSCK alloca n-1 blocchi (da quelli liberi), ci copia i dati del blocco inconsistente e fa puntare n-1 file ai nuovi blocchi allocati, poi aggiorna le tabelle.
### Consistenza su file:
> Solo una tabella del file in uso, ammessi valori > 1
- Se il Link counter > Counter file in uso, ci può essere spreco di spazio se tutti gli utenti eliminano quel file perché il sistema operativo non libera il blocco, FSCK mette il link counter = al Counter dei file in uso
- Se il Link counter < counter file in uso, ci può essere un problema di sicurezza, quando quell’i-node verrà rimosso una directory gli punterà ancora e quindi quando verrà riallocato quella directory avrà accesso a dei dati che magari non dovevano essere condivisi, FSCK setta il link counter = al counter della tabella dei file in uso.
File added
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment