11/03/2014
Kernel
Inter‐process communication
Process management
Scheduling
Mutual exclusion
Interrupt handling
p
g
¾
¾
¾
¾
¾
¾
Compiti del sistema operativo
Creazione e terminazione di processi
Schedulazione
Mutua esclusione
Sincronizzazione
Gestione delle interruzioni
Comunicazione tra processi
Gestione della memoria
Il sistema operativo deve:
¾ Allocazione e deallocazione della memoria ai processi
¾ consentire l'esecuzione concorrente dei vari task
(parallelismo virtuale);
¾ Caricamento dei processi in memoria principale
¾ decidere
d id
l' di di esecuzione
l'ordine
i
d i varii task
dei
t k (scheduling),
( h d li )
rispettando i requisiti specificati;
¾ Gestione della memoria virtuale
¾ Protezione della memoria
¾ risolvere potenziali conflitti di temporizzazione
nell'accesso a risorse condivise (mutua esclusione);
¾ consentire l'esecuzione di eventi asincroni (interruzioni).
Visione a strati
Gestione delle periferiche
Processi utente
¾ Configurazione
Interfaccia utente (Shell)
¾ Inizializzazione
File system
Gestione periferiche
¾ Protezione delle periferiche
¾ Buffering
Gestione della memoria
Gestione dei processi (kernel)
Macchina fisica
1
11/03/2014
File system
¾ Gestione dell'albero del file system
Concorrenza
Confrontando l'esecuzione sequenziale con quella
concorrente, sembra non ci siano vantaggi:
Response times
R1 = 4
¾ Creazione e cancellazione di file
¾ Lettura e scrittura di file
¾ Copia di file
esecuzione
sequenziale
i l
¾ Ricerca di file
R2 = 10
0
2
4
6
8
10
12
R3 = 15
14
¾ Salvataggio e ripristino file
¾ Protezione dei file (controllo degli accessi)
R1 = 10
esecuzione
concorrente
R2 = 15
0
2
Interfaccia utente
¾ Interprete dei comandi utente (Shell)
¾ Interfaccia grafica
¾ Chiamate di sistema (interfaccia verso i processi)
¾ Librerie
6
4
8
10
12
R3 = 14
14
Concorrenza
Risulta vantaggiosa nel gestire task periodici a frequenze
diverse (nei tempi di attesa vengono eseguiti altri task):
esecuzione
sequenziale
(FIFO)
¾ Gestione degli errori
0
2
4
6
8
10
12
14
16
18
20
0
2
4
6
8
10
12
14
16
18
20
esecuzione
concorrente
(Rate Monotonic)
Concorrenza
La concorrenza è la capacità di portare avanti
l'esecuzione di più processi per volta, attraverso
un'alternanza delle esecuzioni:
τ1 τ2
τ3
Multiprogrammazione
Ed è anche importante per realizzare la
multiprogramazione in sistemi multiutente (sfrutta le
attese di input per gestire altri utenti):
esecuzione
q
sequenziale
esecuzione
parallela
esecuzione
concorrente
2
11/03/2014
Concorrenza
Esempio 2
La concorrenza dunque consente di sfruttare
meglio i tempi di inattività dei processi (ad
esempio, attese su dati di ingresso, o attese per la
riattivazione di task periodici).
τ1
Tuttavia, la concorrenza può generare situazioni di
conflitto durante l'accesso a risorse condivise (ad
esempio, quando più task operano su dati globali
comuni).
Ciascun thread incrementa un contatore ogni volta che
rileva un evento:
buffer
globale
τ1
x = counter;;
x = x + 1;
counter = x;
τ1
10
10
τ1
counter
bloccaggio
read(x)
read(y)
3
5
scrittura
buffer
llegge (3,5)
(3 5)
correttamente!
Meccanismo semaforico
Cerca di colpire il bersaglio nel punto (x,y)
La mutua esclusione viene realizzata attraverso un due
primitive wait(s) e signal(s): che utilizzano una variabile di
sistema s, detta semaforo:
τ2
τ1
τ2
(x, y)
x = (a + b)/c;
y = (a − b) /c;
τ2
x: 3
y: 5
x←1
y←8
τ2
Un evento
viene perso!
11
(x, y)
variabili globali
8
τ1
Esempio 2
τ1
3
x = 1
y = 8
8
τ2
Stima la posizione successiva (x,y)
di un bersaglio
read(y)
Soluzione: l'accesso al buffer condiviso dev'essere
consentito ad un task per volta (mutua esclusione):
x = counter;;
x = x + 1;
counter = x;
11
read(x)
Accesso a risorse condivise
counter
counter
x←1
y←8
τ2
τ2
counter
c: 10
legge (3,8)
che non appartiene
alla traiettoria!
τ1
Esempio di conflitto
τ2
x: 3
y: 5
x = 1
y = 8
(x, y)
lettura
buffer
m1 = k1*(ax ‐ x);
m2 = k2*(ay ‐ y);
sezione
critica
wait(s);
x = ... y = …
signal(s);
scrittura
buffer
lettura
buffer
wait(s);
m1 = … x;
m2 = … y;
signal(s);
sezione
critica
3
11/03/2014
Meccanismo semaforico
¾ Ogni risorsa è protetta da un semaforo diverso.
¾ s = 1 ⇒ risorsa libera,
s = 0 ⇒ risorsa occupata.
¾ wait(s):
− se s == 0, il task deve essere bloccato su una coda
associata
i t all semaforo
f
(l politica
(la
liti di gestione
ti
d ll
della
cosa dipende dal SO, di solito è FIFO o prioritaria).
− altrimenti si pone s = 0.
¾ signal(s):
− se ci sono task bloccati, si risveglia il primo in coda
(s rimane a 0), altrimenti pone s = 1.
Note implementative
s = create_sem(n)
crea la struttura semaforo, comprendente un contatore
(s.count) inizializzato a n, e una coda di task (s.queue).
wait(s) {
if (s.count == 0)
<blocca il task su s.queue>
else s.count--;
}
signal(s) {
if (!empty(s.queue))
<sblocca il primo task in s.queue>
else s.count++;
}
Meccanismo semaforico
¾ Se la variabile s è inizializzata a 1, la coppia wait(s)
signal(s) realizza il meccanismo di mutua esclusione:
¾ Un semaforo inizializzato a 0 può essere utilizzato per
attendere un evento generato da un altro task.
τ1
τ1
τ2
Semafori di sincronizzazione
τ2
τ3
R
chiama la signal al verificarsi dell'evento
signal(s);
wait(s);
wait(s)
bloccato
τ1
wait(s)
τ2
τ3
signal(s)
signal(s)
bloccato
wait(s)
τ1
bloccato
signal(s)
wait(s)
s = 1
priorità
s = 0
s = 1
Risorse multi-unità
¾ Un semaforo che può assumere solo gli stati 0 e 1 è
detto semaforo binario.
¾ Esistono risorse multi‐unità che ammettono l'accesso
simultaneo di più task. Se le unità sono n, il semaforo
viene inizializzato ad n.
¾ wait(s):
− se s == 0, il task deve essere bloccato su una coda
associata al semaforo;
− altrimenti si decrementa s.
¾ signal(s):
− se ci sono task bloccati, si risveglia il primo in coda
per farlo entrare, altrimenti si incrementa s.
signal(s)
τ2
Gestione dei processi
Un processo rappresenta l'unità di esecuzione in un SO.
Programma: entità passiva descritta dal codice sorgente.
Processo:
entità attiva determinata dall'esecuzione del
programma su un particolare insieme di dati.
Un processo è rappresentato dai seguenti elementi:
codice:
istruzioni compilate ed eseguibili;
dati:
spazio di memoria per le variabili globali;
contesto:
stato dei registri di CPU;
stack:
spazio di memoria per le variabili locali.
parametri: tipo, priorità, argomenti, ...
4
11/03/2014
Gestione dei processi
Ready queue
¾ I processi non condividono memoria!
In un sistema concorrente, più task possono essere attivi
ma solo uno può essere in esecuzione (running).
¾ Processi diversi
eseguono codici diversi;
accedono a spazi di memoria distinti.
¾ Un task attivo che non è in esecuzione si dice pronto
(ready).
¾ Essi possono comunicare mediante un meccanismo a
scambio di messaggi messo a disposizione dal SO:
P1
P2
channel
¾ I task p
pronti sono mantenuti in una coda ((readyy q
queue),
),
gestita mediante una politica di scheduling.
¾ Il processore viene assegnato al primo task in coda
attraverso una procedura detta dispatching.
activation
dati
dati
Ready queue dispatching
τ3
Processi e thread
τ2
τ1
termination
CPU
Preemption
¾ Un processo può essere costituito da più sottoprocessi
concorrenti, detti thread.
¾ I thread di uno stesso processo
condividono lo stesso spazio di memoria;
hanno stack distinti;
possono eseguire lo stesso codice. τ1 τ2
E' un meccanismo che consente di interrompere
l'esecuzione di un task a favore di un altro task ritenuto più
importante. Il task interrotto viene rimesso in coda pronti.
activation
τ3 Pi
Ready queue
τ3
τ2
τ1
dispatching
termination
CPU
preemption
Esempio di processo
composto da 3 thread:
¾ La preemption facilita la concorrenza e consente di
ridurre i tempi di risposta di task ad alta priorità.
Nel seguito indicheremo come task
una generica attività di calcolo
concorrente (processo o thread).
¾ Può essere disabilitata (del tutto o temporaneamente)
per garantire la consistenza di certe operazioni critiche.
dati
Task
Schedulazione
¾ Sequenza di istruzioni che, in assenza di altre attività,
viene eseguita dal processore in modo sequenziale fino
al suo completamento.
activation time
Task τi
Ci
start time
ai
computation
time
finishing time
si
fi
Ri
La quantità fi − ai
prende il nome di tempo di risposta Ri
t
E' un particolare assegnamento di task al processore che
determina la sequenza temporale di esecuzione:
Formalmente, dato un insieme di task Γ = {τ1, ..., τn}, una
schedulazione è una funzione costante a tratti σ: R+ → N
che
h associa
i un intero
i
k ad
d ognii intervallo
i
ll temporale
l [t,
[ t+1)
1)
col seguente significato:
k = 0 in [t, t+1) il processore è IDLE k > 0 in [t, t+1) il processore esegue τk
5
11/03/2014
Schedulazione
τ1
idle
τ2
Stati di un task
τ3
idle
BLOCKED
σ(t)
signal
wait
3
2
dispatching
1
0
t1
t2
t3
t4
t
activation
termination
READY
¾ Ogni intervallo [ti, ti+1) viene detto time slice.
RUNNING
preemption
¾ Negli istanti t1, t2, t3, e t4 il processore effettua un
cambio di contesto (context switch).
ACTIVE
Schedulazione preemptive
Real-Time Task
¾ Un task di tipo real‐time è caratterizzato da un vincolo
sul tempo di risposta, detto deadline:
priorità
τ1
τ2
deadline relativa Di
τ3
0
2
4
6
8
10
12
14
16
18
20
τi
ai
σ(t)
si
fi
tempo di risposta Ri
t
di
deadline assoluta
(di = ai + Di)
3
Un task real‐time τi si dice fattibile se termina
entro la sua deadline assoluta, ossia se fi ≤ di,
o equivalentemente, se Ri ≤ Di
2
1
0
0
2
4
6
8
10
12
14
16
18
20
Stati di un task
priorità
Slack e Lateness
Di
running
τ1
running
τ2
ready
running
τ3
0
2
4
running
ready
6
8
10
τi
running
12
14
16
18
ai
si
fi
Ri
20
slacki = di - fi
Di
σ(t)
τi
3
2
1
0
0
2
4
6
8
10
12
14
16
18
20
ai
t
di
si
lateness Li = fi - di
di
fi
t
Ri
6
11/03/2014
Complessità
• Nel 1975, Garey e Johnson hanno dimostrato che il
problema generale di trovare una schedulazione
fattibile è di tipo NP hard.
• Tuttavia è possibile trovare algoritmi di complessità
polinomiale
li
i l in
i casii particolari:
ti l i
¾ Singolo processore
¾ Task completamente preemptive
¾ Attivazioni simultanee
¾ Restrizioni sui vincoli
Problema dello scheduling
Dato un insieme Γ di n task, un insieme P di m
processori, e un insieme R di r risorse, una
schedulazione è un assegnamento di P e R a Γ in ogni
intervallo temporale [t, t+1):
Importanza della complessità
• Si consideri un’applicazione con n = 30 task su una
macchina in cui il passo elementare impiega 1 μs
• Si considerino tre algoritmi con complessità:
A1: O(n)
O( )
A2: O(
O(n8)
A3: O(8n)
Γ
P
Scheduling
algorithm
σ
30 μs
40.000
miliardi di anni
182 ore
R
Problema dello scheduling
Misura di prestazioni
• Una schedulazione σ si dice fattibile se soddisfa un
insieme di vincoli specificati sui task in fase di progetto.
• Fattibilità:
∀i
Ri ≤ Di
• Un insieme di tasks Γ si dice schedulabile con un
algoritmo A, se A genera una schedulazione fattibile.
• Tempo medio di risposta:
R =
1 n
∑ ( fi − ai )
n i =1
Esempi di vincoli
• Tempo di completamento:
tc = max ( f i ) − min (ai )
• Massima Lateness:
Lmax = max( f i − d i )
¾ Temporali:
attivazione, completamento, esecuzione.
¾ di precedenza: impongono un ordinamento tra i task.
¾ su risorse:
sincronizzazione per mutua esclusione.
• Numero di late task:
i
i
i
N late =
n
∑ HS ( f
i =1
i
− di )
7
11/03/2014
Algoritmi Classici
Shortest Job First (SJF)
¾ First Come First Served
Seleziona il task con il tempo di calcolo più corto.
¾ Shortest Job First
Può essere eseguito in modo preemptive o
non p
preemptive
p
¾ Priority Scheduling
Minimizza il tempo di risposta medio
¾ Round Robin
46
First Come First Served
SJF - Ottimalità
Assegna la CPU ai task in base al loro tempo di
arrivo (intrinsecamente non preemptive):
τ3
σ
τ1
τ2
τ1
τ2
a1 a2 a3 a4
s2
≠ SJF
L
σ’
Ready queue
τ4
σ
CPU
τ3
s3
S
S
r0
L
fS’ < fL
t
fL’ = fS
fS’ + fL’ ≤ fS + fL
τ4
s4
t
f4
R (σ') =
1 n
1 n
( f 'i − ri ) ≤ ∑ ( f i − ri ) = R (σ)
∑
n i =1
n i =1
47
First Come First Served
SJF - Ottimalità
‐ Imprevedibilità
σ
I tempi di risposta dipendono dai tempi di arrivo.
a1 a2 a3
R1 = 20
R2 = 26
4
8
a3 a2 a1
τ3
0
12
R1 = 26
16
R2 = 8
τ2
4
20
24
τ3
28
t
12
16
20
R3 = 2
28
σ*
≥ R (σ*)
R (σ SJF ) è il minimo tempo di risposta
t
24
...
...
σ* = σSJF
32
τ1
8
σ’’
R (σ) ≥ R (σ') ≥ R (σ' ' )
R3 = 26
τ2
τ1
0
σ’
ottenibile da un algoritmo
32
45
48
8
11/03/2014
SJF è adatto per il Real-Time?
‐ Non è ottimo nel senso della fattibilità
τ2
τ1
0
4
8
12
16
4
8
12
d3
28
32
d2
d3
28
32
τ3
20
24
d1
SJF not feasible
τ3
τ2
0
d2
d1
A ≠ SJF feasible
16
20
24
‐ La coda ready è gestita con FCFS, ma ...
‐ Ogni task τi non può eseguire per più di Q
unità di tempo (Q = time quantum).
‐ Esaurito Q,
Q τi viene inserito in coda pronti.
pronti
t
τ1
Round Robin
READY queue
CPU
t
Q expired
49
52
Scheduling Prioritario
Round Robin
‐ Ogni task ha una priorità: Pi ∈ [0, 255]
n = numero di task nel sistema
‐ Il task selezionato per l’esecuzione è quello
con la priorità più elevata.
nQ
nQ
t
‐ Task
T k a parii priorità
i ità sono serviti
iti con FCFS.
FCFS
C
Ri ≅ (nQ) i = nCi
Q
Q
NOTA:
pi ∝ 1/Ci
pi ∝ 1/ai
⇒
⇒
SJF
FCFS
Time sharing
Ogni task si comporta come se fosse eseguito da
solo su un processore dedicato n volte più lento.
50
53
Scheduling Prioritario
Round Robin
‐ Problema: starvation
task a bassa priorità possono subire lunghi ritardi per
la preemption di task a priorità più elevata.
‐ se Q > max (Ci) allora RR ≡ FCFS
‐ se Q ≅ context switch time (δ) allora
n(Q
(Q + δ))
n(Q
(Q + δ))
‐ Soluzione: aging
t
la priorità cresce con il tempo di attesa.
Q+δ
51
Ri ≅ n(Q + δ)
⎛Q+δ⎞
Ci
⎟⎟
= nCi ⎜⎜
Q
⎝ Q ⎠
54
9
11/03/2014
Multi-Level Scheduling
system tasks
PRIORITY
High priority
interactive tasks
Medium priority
RR
CPU
batch tasks
Low priority
FCFS
55
Multi-Level Scheduling
priority
CPU
56
10
© Copyright 2024 Paperzz
