Sistemi Operativi Giuseppe Prencipe Il modello a thread

Il modello a thread : motivazioni
Sistemi Operativi
Giuseppe Prencipe
 Nel modello a processi, ogni processo
ha il suo spazio di indirizzamento
privato ed il modo per interagire è
quello di utilizzare i meccanismi di IPC
messi a disposizione dal sistema
Thread
Es.: send, receive
 Questo implica alti costi di interazione,
se i dati da scambiare sono molti!
1
Scambio dati fra due processi
Scambio dati fra due processi
 Come posso passare informazioni fra
 Due processi diversi non hanno spazio
di indirizzamento comune!!!
2
Proc. P2
P1 e P2 ?
Proc. P1
Stack1
Aree di memoria diverse!
Stack2
Stack1
dati2
dati1
testo2
testo1
1
Stack2
dati2
dati1
Proc. P2
Proc. P1
testo1
3
????
?????
testo2
4
Esempio: send-receive
Esempio: send-receive
 Una possibile implementazione :
 IPC -- Inter Processor Communication)
Il canale è una struttura dati del kernel
snd e rcv sono due chiamate di sistema
Es.: send, receive
Proc. P2
Proc. P1
Proc. P2
Proc. P1
Stack2
Stack1
snd
Stack2
Stack1
snd
rcv
rcv
dati1
dati2
dati1
dati2
testo1
testo2
testo1
testo2
5
Esempio: send-receive
Esempio: send-receive
 Altra possibile implementazione :
 Costi :
Dati sono copiati almeno una volta dal processo
mittente al processo destinatario
Si paga : il cambio di contesto, l’overhead delle
chiamate di sistema per snd e rcv
Proc. P2
Proc. P1
Stack2
Stack1
snd
dati1
testo1
rcv
Il canale è un file ‘speciale’ accessibile ai due
processi
snd e rcv corrispondono a chiamate di sistema
che effettuano letture/scritture su un file
il costo non migliora!!!!!!!!!!!!! Pipe in UNIX!!!!
Proc. P2
Proc. P1
Stack2
Stack1
snd
dati2
dati1
testo1
testo2
7
2
6
rcv
dati2
testo2
8
Il modello a thread: motivazioni
Quindi : se i dati da
scambiare sono molti avere
spazi di indirizzamento
separati è estremamente
costoso !
 Nel modello a processi, l’attivazione di un
processo, il cambio di contesto sono
operazioni molto complesse che richiedono
ingenti quantità di tempo per essere portate
a termine
 Tuttavia a volte l’attività richiesta ha vita
relativamente breve rispetto a questi tempi
Es.: invio di una pagina html da parte di un
server Web
 troppo ‘leggera’ per motivare un nuovo processo
9
Thread
Il modello a thread
 Thread (processo leggero – lightweight
 Idee di base dietro il modello a thread :
process, LWP)
permettere la definizione di attività
‘leggere’ (lightweight processes -LWP) con costo di attivazione e
terminazione limitato
possibilità di condividere lo stesso spazio
di indirizzamento
Identificatore di thread
Contatore di programma
Insieme di registri
Pila
 Condivide con gli altri thread che
appartengono allo stesso processo
 Ogni processo racchiude più flussi di
Sezione codice
Sezione dati
Risorse di sistema (es.: file aperti)
controllo (thread) che condividono le
aree testo e dati
11
3
10
12
Processo a singolo e multi
thread
Struttura di un processo
mutithreaded
Stack del thread T1
Stack del thread T2
Stack del thread T3
T2
T1
dati
T3
testo
Processo P1 (Multithreaded)
13
Thread
 Di solito un’applicazione svolge diversi compiti
 Es.: browser
Rappresentazione sullo schermo di immagini e testo
Reperimento dati nella rete
 Es.: elaboratore testi
Rappresentazione grafica
Lettura dati immessi da tastiera
Correzione ortografica e grammaticale
Thread
 Se l’applicazione fosse eseguita come un
singolo thread (processo)
Come si fa per fare tutto?
Crea un processo per ogni attività....
 CAMBIO DI CONTESTO!!!!
Molto costoso (implica un cambio dello
spazio di indirizzamento, copia di vari dati,
ecc....)
 Es.: server Remote Procedure Call
15
4
14
16
Il modello a thread
Il modello a thread
 Se un processo P1 ammette un singolo
 Se un processo P1 più thread di controllo
thread di controllo
lo stato di avanzamento della computazione
di P1 è determinato univocamente da :
 valore del PC (prossima istruzione da eseguire)
 valore di SP/PSW e dei registri generali
 contenuto dello Stack (ovvero storia delle
chiamate di funzione passate)
 stato del processo : pronto, in esecuzione,
Lo stato di avanzamento della computazione
di ogni thread è dato da :
 valore del PC (prossima istruzione da eseguire)
 valore di SP/PSW e dei registri generali
 contenuto dello Stack privato di quel thread
 stato del thread : pronto, in esecuzione, bloccato
 Sono invece comuni a tutti i thread :
bloccato
 stato dell’area testo e dati
 stato dei file aperti e delle strutture di IPC
utilizzate
stato dell’area testo e dati
stato dei file aperti e delle strutture di IPC
utilizzate
17
Il modello a thread
18
Il modello a thread
 Quindi, lo stato di avanzamento di un
processo multithreaded è dato da
lo stato di avanzamento di tutti i suoi
thread
stato dell’area testo e dati
stato dei file aperti e delle strutture di IPC
utilizzate
 Condiviso da tutti i thread di un
processoPrivato a ogni thread
19
5
 Privato a ogni
thread
20
Word processor con 3 threads
Uso dei thread
Applicazioni che :
 possono essere suddivise in più
flussi di controllo
 interagiscono molto strettamente
la condivisione dello spazio di
indirizzamento e delle altre risorse
permette di interagire senza pagare
copie e cambi di contesto
Comunica con l’utente
Formatta il testo
Salva su dico
21
Struttura di un word
processor multithreaded
Legge i caratteri
da tastiera e
visualizza
StackT1
StackT2
Struttura di un word
processor multithreaded
Formatta
il testo
Formatta
il testo
Legge i caratteri
da tastiera e
visualizza
T2
T2
T1
dati
testo
T3
disco
T1
StackT3
dati
Salva
periodicamente
su disco
23
6
22
tastiera
testo
T3
Salva
periodicamente
su disco
24
Un web server multithreaded
Un web server multithreaded
All’arrivo di una nuova
richiesta dalla rete :
- il dispatcher CREA un
nuovo thread ‘worker’
che controlla se la
pagina sta nella
cache, e altrimenti
va a leggere la
pagina da disco
Thread
Dispatcher
Dispatcher
T1
Connessione
di rete
(Network)
Connessione
di rete
(Network)
testo
Cache (pagine
richieste
recentemente)
testo
Processo Web Server
25
Un web server multithreaded
work1
work1
Dispatcher
Connessione
di rete
(Network)
work2
7
testo
WEB Cache
(pagine
richieste
recentemente)
26
Un web server multithreaded
Disco/i
Dispatcher
WEB Cache (pagine
richieste recentemente)
work2
Ogni worker
1) legge le
informazioni
su cache o
disco
2) aggiorna la
cache
3) risponde
alla richiesta,
4) TERMINA
testo
27
28
Un web server multithread
Un web server multithreaded
 Possibile struttura del codice del web server
Dispatcher riceve le richieste
Dispatcher sceglie un worker
Worker controlla la cache
(a) dispatcher thread
(b) worker thread
 buf e page sono appropriate strutture per
memorizzare le pagine web
29
Implementazione dei thread
Vantaggi
 Ogni thread è descritto da un
 Tempo di risposta
descrittore di thread :
Maggiore interattività
thread identifier (tid)
 Condivisione delle risorse
Tutti i thread condividono memoria e risorse
 Economia
Minore costo del cambio di contesto
 Uso di più unità d’elaborazione
Molti vantaggi nelle macchine parallele
(thread eseguiti in parallelo)
31
8
30
PC, SP, PCW, registri generali
info sulla memoria occupata dallo stack
privato del thread
stato del thread (pronto, in esecuzione,
bloccato)
processo di appartenenza (pid, process
identifier)
32
User–level thread
Implementazione dei thread
 Realizzati da una libreria di normali
 Thread table :
funzioni che girano in modo utente
tabella che contiene i descrittori di thread
simile della process table
se ne può avere una unica nel kernel o
una privata di ogni processo
thread_create(), thread _exit(),
thread_wait()…
Strato sopra il nucleo
 Il SO e lo scheduler non conoscono
 Possono essere realizzati da :
l’esistenza dei thread e gestiscono
solamente il processo intero
 Lo scheduling dei thread viene effettuato
dal run time support della libreria
librerie che girano interamente in stato
utente (user level thread)
all’interno del kernel (kernel level thread)
33
34
User–level thread
User–level thread
St1
St2
St3
 La thread table è una struttura privata
del processo
 C’è una TT per ogni processo
 I thread devono rilasciare
esplicitamente la CPU per permettere
allo scheduler dei thread di eseguire un
altro thread
thread _yield ()
35
9
T1
T2
dati
testo
T3
RTS
Tabella
dei processi
Thread
table
Spazio
Utente
Spazio
Kernel
36
User–level thread
User–level thread
 Quando un thread esegue un chiamata di sistema e si
blocca in attesa di un servizio tutto il processo a cui
appartiene viene bloccato
Es.: nel web server una qualsiasi lettura da disco blocca tutti i
thread!
 Addio parallelismo ...
 Problemi di scheduling: un thread in esecuzione non
può essere interrotto a meno che non rilasci
esplicitamente la CPU
Blocco di tutto il sistema in caso di SC bloccante!!!!
 Esempi
POSIX Pthreads
Mach C-threads
Solaris threads
37
38
Kernel–level thread
Kernel–level thread
• Thread table unica (nel kernel)
• Le primitive che lavorano sui thread
sono system call
St1
St2
St3
dati
testo
• thread_create(), thread _exit(), thread_wait()...
• Non è necessario che un thread rilasci
esplicitamente la CPU
• Le system call possono bloccarsi senza
bloccare tutti i thread di quel processo
T1
Thread
table
39
10
T2
Tabella
dei processi
T3
Spazio
Utente
Spazio
Kernel
40
Kernel–level thread
Kernel–level thread
 Implementati nel nucleo
 Il nucleo fornisce un insieme di SC che
supportano i thread
 Esempi
-
Windows 95/98/NT/2000
Solaris
Tru64 UNIX
BeOS
Linux
41
42
Modelli ibridi
User–level thread vs kernellevel thread
St1
 User—level
Creazione di thread e thread switch molto veloce
Si può effettuare uno scheduling “personalizzato”,
dipendente dall’applicazione
Gestione problematica delle system call bloccanti
T1
 librerie di SC non bloccanti
St3
dati
testo
T2
T3
RTS
 Kernel—level
Buona gestione delle SC bloccanti
Cambio di contesto più lento (SC al nucleo)
Creazione e terminazione thread più lenta (SC al nucleo)
43
11
St2
Thread
table K
Thread
table U
Tabella
dei processi
Spazio
Utente
Spazio
Kernel
44
Modelli di programmazione
multithread
Modelli ibridi
 Da molti a uno
Molti thread a livello utente corrispondono a
un singolo thread a livello del nucleo
Gestione dei thread nello spazio utente
L’intero processo si blocca se un thread
invoca una SC bloccante
Green threads – Solaris2
45
46
Modelli di programmazione
multithread
Molti a uno
 Da uno a uno
Fa corrispondere a ciascun thread a livello
utente un thread a livello del nucleo
Maggiore grado di concorrenza
 Se un thread invoca una SC bloccante, è
possibile eseguire un altro thread (perchè??)
La creazione di ogni thread utente comporta
la creazione di un thread a livello del nucleo
 Per ovviare all’overhead, si limita il numero max
di thread gestibili dal sistema
 Windows NT e Windows 2000
47
12
48
Modelli di programmazione
multithread
Molti a molti
 Da molti a molti
Mette in corrispondenza più thread del
livello utente con un numero minore o
uguale di thread del livello del nucleo
Concorrenza e nessun limite sul numero di
thread
 In caso di SC bloccante??
UNIX, Solaris2, Windows NT/2000 with the
pacchettoThreadFiber
49
fork e exec
Cancellazione
 Se un thread invoca una fork
 Cancellare un thread serve a far
terminare un thread prima che completi
il suo compito
il nuovo processo contiene un duplicato del
solo thread invocante o di tutti i thread del
processo
Es.: diversi thread stanno effettuando una
ricerca su un DB, uno di essi riporta il
risultato e tutti gli altri vengono cancellati
Es.: terminazione del caricamento di una
pagina web
 Se un thread invoca una exec
Il programma specificato come parametro
sostituisce il processo (inclusi i thread)
 Se si invoca la exec immediatamente
 Un thread da cancellare è spesso detto
dopo la fork, conviene duplicare?
thread bersaglio
51
13
50
52
Gestione dei segnali
Cancellazione
 I segnali si usano per comunicare ai processi il
verificarsi di determinati eventi
 Asincrona
Un thread fa immediatamente terminare il thread
bersaglio
 Differita
Il thread bersaglio controlla periodicamente se deve
terminare
Tipicamente esiste un thread che segnala la
necessità di cancellare un certo thread bersaglio
 Problemi possono nascere se il thread ha
All’occorrenza di un particolare evento si genera un
segnale
S’invia il segnale al processo
Una volta ricevuto, si gestisce il segnale
 Gestore predefinito
 Gestore definito dall’utente
Segnali possono essere sincroni, o
 Es.: divisione per zero
 Si inviano allo stesso processo che ha causato l’operazione che
ha generato il segnale
assegnate delle risorse
Asincroni
Es.: thread viene cancellato mentre aggiorna dati
che condivide con altri thread
 Es.: Scadenza temporizzatore, terminazione processo con
combinazione di tasti
 Di solito si inviano a un altro processo
53
Gruppi di thread
Gestione dei segnali
 Web server
Crea un nuovo thread per ogni richiesta  non si pone un
limite al numero di thread attivi nel sistema
 Per i processi a singolo thread, la gestione è
 Gruppi di thread
semplice: si fa riferimento al processo
interessato
 Con il multithread
Alla creazione di un processo, si crea un certo numero di
thread organizzati in gruppo
Quando il server riceve una richiesta, la invia a uno dei thread
del gruppo (
Si invia il segnale al thread interessato
Si invia il segnale a ogni thread del processo
Si invia il segnale a specifici thread del processo
Si definisce un thread specifico per ricevere tutti i
segnali diretti al processo
 Se ne esiste uno disponibile  OK; else, ne attende uno
disponibile
 Vantaggi
Gestione più rapida: perchè????
 Il thread già esiste!!
Limite al numero di thread nel sistema
 Il metodo scelto dipende dal tipo di segnale
 Numero di thread per gruppo determinate tramite euristiche e/o
dinamicamente
55
14
54
56
Pthreads
Thread Solaris 2
 Standard POSIX che definisce l’API
(Application Program Interface) per la
creazione e la sincronizzazione dei thread
Non è una realizzazione
 Librerie Pthreads esistono per UNIX
 Es. a pag. 144 del libro di testo (in C)
57
58
Thread Windows 2000
Processi Solaris
 Implementa il modello uno a uno
 Ogni thread contiene
- thread id
- insieme di registri
- stack utente e kernel separati
- area privata di memorizzazione dati
59
15
60
Thread in Java
Thread Linux
 Linux li chiama tasks
 Permette la gestione dei thread a livello di
 La creazione avviene tramite la SC clone()
 Clone()
permette al task figlio di
condividere lo spazio di indirizzi del task
padre
linguaggio di programmazione
 Sono gestiti dalla JVM (non da una libreria
a livello utente o nucleo)
 Tutti i programmi Java prevedono almeno
un thread di controllo
61
62
Thread in Java
 Creazione thread tramite classe Thread
 Esecuzione tramite metodo run()
Il metodo start invocato all’interno del processo chiamante crea
effettivamente il nuovo thread
 Assegnazione memoria e inizializzazione di un nuovo thread nella
JVM
 Chiamata del run, che rende il thread disponibile a essere esguito
dalla macchina virtuale
 NOTA: run non viene mai chiamato esplicitamente, ma sempre
tramite start
Per oggi basta!!!!
 Es. Pag. 150 del libro di testo: quanti thread vengono
creati?
 Come i thread Java vengono implementati nel SO
dipende da come la JVM è implementata
Windows: uno a uno, Solaris: molti a molti
63
16
64