Sistemi Operativi
Dispense di teoria — versione compatta
Corso di Laurea in Informatica — Università degli Studi di Torino
A.A. 2026/2027
1
Indice Capitoli 6 e 7 — Sincronizzazione dei processi
Parte I — Teoria 6.1 Introduzione: processi cooperanti e dati condivisi
6.2 Il problema della sezione critica
Capitolo 1 — Introduzione ai sistemi operativi 6.3 Le sezioni critiche del sistema operativo
1.1 Che cos'è un sistema operativo 6.4 Sincronizzazione via hardware
1.2 Architetture single-core e multi-core 6.5 I semafori (Dijkstra, 1965)
1.3 Organizzazione di un sistema elaborativo 6.6 Implementazione dei semafori
1.4 Struttura della memoria e caching 6.7 Deadlock e starvation
1.5 Struttura di I/O 7.1 Problemi classici di sincronizzazione: produttori e
1.6 Multitasking e time-sharing consumatori
1.7 Compiti del sistema operativo 7.2 Il problema dei lettori e degli scrittori
1.8 Come il SO mantiene il controllo della macchina 7.3 Il problema dei cinque filosofi
Capitolo 2 — Strutture dei sistemi operativi Capitolo 8 — Stallo dei processi (deadlock)
2.1 I servizi offerti dal sistema operativo 8.1 Che cos'è un deadlock
2.2 L'interfaccia col sistema operativo 8.2 Un esempio con i semafori: i due nastri
2.3 Programmi e servizi di sistema 8.3 Un altro esempio: il ponte a una sola corsia
2.4 Le chiamate di sistema (system call) 8.4 Modello del sistema
2.5 Le attività di gestione del sistema operativo 8.5 Caratterizzazione del deadlock: il grafo di assegnazione
2.6 Il sistema operativo come macchina virtuale delle risorse
Capitolo 3 — Processi 8.6 Metodi per la gestione dei deadlock
3.1 Il processo come unità di lavoro del sistema operativo Capitolo 9 — Memoria centrale
3.1.1 Concetto di processo 9.1 Introduzione: perché gestire la memoria primaria
3.1.2 Stato del processo 9.2 Binding (associazione) degli indirizzi
3.1.3 Process Control Block (PCB) 9.3 Spazio degli indirizzi logici e fisici
3.2 Scheduling dei processi 9.4 Le librerie
3.2.3 Il cambio di contesto (context switch) 9.5 Tecniche di gestione della memoria primaria e swapping
3.2.1 Code di scheduling 9.6 Allocazione contigua della memoria primaria
3.2.2 CPU scheduler 9.7 Paginazione della memoria: metodo di base
3.3 Operazioni sui processi 9.9 Paginazione: osservazioni, vantaggi e svantaggi
3.3.1 Creazione di un processo 9.10 Supporto hardware alla paginazione: il TLB
3.3.2 Terminazione di un processo 9.11 Pagine condivise
3.4 Comunicazione tra processi 9.12 Paginazione a più livelli (paginazione gerarchica)
3.5 Esempio: il problema del produttore-consumatore 9.13 Tabella delle pagine invertita (IPT)
3.5 Inter-Process Communication (IPC) 9.14 Il supporto alla paginazione nei vecchi processori Intel
Capitolo 4 — Thread 9.15 Conclusioni
4.1 Motivazioni: perché i thread Capitolo 10 — Memoria virtuale
4.2 Processi a singolo thread e processi multi-thread 10.1 Memoria virtuale: introduzione
4.3 Il context switch tra peer thread: processi pesanti e 10.2 Paginazione su richiesta (Demand Paging)
leggeri 10.3 Prestazioni della paginazione su richiesta
4.4 Creazione e sincronizzazione dei thread 10.4 L'area di swap
4.5 Scheduling dei thread 10.5 Sostituzione delle pagine
4.6 Vantaggi nell'uso dei thread 10.6 Algoritmi di sostituzione delle pagine
4.7 Thread e architetture multi-core 10.7 Sostituzione secondo l'ordine d'arrivo (FIFO)
4.8 CPU/core multithreaded: superscalarità e Simultaneous 10.8 Sostituzione ottimale delle pagine (OPT)
Multi-Threading 10.9 Sostituzione LRU (Least Recently Used)
4.9 Dual-threaded e dual-core, convenienza dell'SMT, 10.10 Approssimazioni di LRU
esempi di CPU 10.11 Allocazione dei frame
Capitolo 5 — Scheduling della CPU 10.12 Allocazione globale e locale
5.1 Concetti fondamentali 10.13 Thrashing
5.2 Criteri di scheduling 10.14 Altre considerazioni: dimensione delle pagine
5.3 Algoritmi di scheduling 10.15 Struttura dei programmi
5.3.1 First Come, First Served (FCFS) 10.16 Casi reali: Windows 10
5.3.2 Shortest Job First (SJF) 10.17 Casi reali: Solaris
5.3.4 Scheduling a priorità Capitolo 11 — Memoria di massa
5.3.3 Scheduling Round Robin (RR) 11.1 Struttura del disco rigido
5.3.5 Scheduling a code multiple (Multilevel Queue 11.2 Mappatura degli indirizzi
Scheduling) 11.3 Scheduling dei dischi rigidi
5.3.6 Scheduling a code multilivello con retroazione (MFQS) 11.4 Formattazione del disco e blocco di avviamento
5.5 Scheduling per sistemi multi-core 2
11.5 Gestione dell'area di swap 14.2 Il disco come array di blocchi
11.6 Sistemi RAID 14.3 Metodi di allocazione dei file
11.7 Memorie a stato solido 14.4 Allocazione contigua
14.5 Allocazione concatenata
Capitolo 13 — Interfaccia del file system 14.6 La variante della FAT (File Allocation Table)
13.0 Il file system: una visione d'insieme 14.7 Allocazione indicizzata
13.1 Il concetto di file 14.8 Gli i-node di Unix
13.2 Metodi d'accesso 14.9 NTFS
13.3 La struttura delle directory 14.10 Efficienza e prestazioni
Accesso rapido ai file: apertura e chiusura 14.11 Gestione dello spazio libero
13.4 Protezione 14.12 I link Unix: i-node e nomi dei file
Capitolo 14 — Realizzazione del file system 14.13 Gli hard link (link fisici)
14.1 Struttura a livelli del file system 14.14 I symbolic link (link simbolici)
3
Capitolo 1 — Introduzione ai sistemi operativi
Questo primo capitolo ha lo scopo di dare una visione d'insieme di che cosa sia un sistema operativo, di quali problemi debba risolvere
e di quali meccanismi hardware si serva per farlo. Partiremo da una definizione intuitiva, per poi richiamare alcuni aspetti dell'archi‐
tettura dei calcolatori moderni (processori multi-core, interruzioni, gerarchia delle memorie, dispositivi di I/O e DMA) che sono indi‐
spensabili per capire come lavora il sistema operativo. Introdurremo quindi i concetti di multiprogrammazione e time-sharing, elenche‐
remo i grandi compiti del sistema operativo (che corrispondono, in buona sostanza, ai capitoli successivi del corso) e infine vedremo i
tre meccanismi fondamentali con cui il sistema operativo mantiene sempre il controllo della macchina: la duplice modalità di funziona‐
mento della CPU, il timer e la protezione della memoria.
1.1 Che cos'è un sistema operativo
Una definizione intuitiva
Intuitivamente, possiamo dire che un sistema operativo (SO) è un intermediario tra l'utente – o, più precisamente, i programmi ap‐
plicativi che l'utente utilizza – e l'hardware del calcolatore. L'hardware, da solo, è un insieme di componenti fisiche (processore, me‐
morie, dischi, schede di rete, tastiera, schermo...) che sanno eseguire operazioni molto elementari e che vanno pilotate in modo pre‐
ciso e spesso complicato. Il sistema operativo è costituito da un insieme di programmi che gestiscono l'utilizzo delle risorse fisiche
di cui è fatto un computer: in particolare la memoria primaria e la memoria secondaria, le periferiche, e la stessa CPU.
Possiamo immaginare il sistema come organizzato a strati (si veda la figura 1.1 del testo): in basso c'è l'hardware, sopra di esso il si‐
stema operativo, poi i programmi applicativi (editor, compilatori, browser, basi di dati...) e infine, in cima, gli utenti che usano questi
programmi.
+-----------+ +-----------+ +-----------+
| utente 1 | | utente 2 | ... | utente n |
+-----------+ +-----------+ +-----------+
\ | /
+-----------------------------------------------------+
| programmi applicativi e di sistema |
| (compilatori, editor, browser, basi di dati, ...) |
+-----------------------------------------------------+
| sistema operativo |
+-----------------------------------------------------+
| hardware |
| (CPU, memoria, dispositivi di I/O, ...) |
+-----------------------------------------------------+
Gli applicativi non parlano quasi mai direttamente con l'hardware: ogni volta che hanno bisogno di una risorsa fisica (leggere un file
dal disco, scrivere sullo schermo, ottenere altra memoria) si rivolgono al sistema operativo, che fa da tramite.
Le funzioni di un sistema operativo
Entrando un po' più nel dettaglio, un sistema operativo svolge tre funzioni principali.
Fornisce gli strumenti per un uso corretto e facile delle risorse della macchina (la CPU, le memorie, le periferiche...). Il pro‐
grammatore non deve conoscere i dettagli elettrici di un disco o della scheda video: il SO offre astrazioni semplici e uniformi,
come i file o i processi, con cui lavorare.
Alloca le risorse nella maniera più conveniente da un punto di vista globale. Su un computer girano tipicamente molti pro‐
grammi, che competono per la CPU, la memoria e i dispositivi. Il SO decide chi ottiene cosa e quando, cercando di massimizzare
l'efficienza complessiva del sistema e non il vantaggio del singolo programma.
Controlla l'esecuzione dei programmi in modo da prevenire gli usi impropri e da limitare i danni causati da errori, malfunzio‐
namenti e attacchi intenzionali. Un programma scritto male (o scritto apposta con cattive intenzioni) non deve poter compro‐
mettere il funzionamento degli altri programmi o del sistema nel suo complesso.
I due obiettivi primari
Le funzioni appena elencate si possono riassumere in due obiettivi primari, che corrispondono a due diversi punti di vista da cui si
può guardare il sistema.
Punto di vista dell'utente: il SO deve rendere il sistema semplice da usare. In primo luogo l'utente vuole poter organizzare i pro‐
pri file e lanciare i propri programmi senza doversi preoccupare di come queste operazioni siano realizzate a basso livello.
Punto di vista della macchina: il SO deve rendere il sistema efficiente e sicuro, cioè allocare in modo efficiente e sicuro le varie
risorse – soprattutto memoria e CPU – tra le varie applicazioni e, quando il sistema è usato da più persone, tra i vari utenti.
I due obiettivi non sono sempre in armonia: un sistema molto comodo da usare può sprecare risorse, e un sistema estremamente ef‐
ficiente può essere scomodo. Gran parte delle scelte progettuali che studieremo nel corso sono compromessi tra queste due esigenze.
4
Dove finisce il sistema operativo?
All'interno di un computer il confine tra il sistema operativo e le altre componenti software non è sempre ben definibile. Ad esem‐
pio: l'interfaccia grafica fa parte del sistema operativo? La risposta dipende dal sistema e anche dall'epoca. Nel passaggio da MS-DOS
a Windows l'interfaccia grafica si è progressivamente integrata nel SO, ma inizialmente non ne faceva parte: le prime versioni di
Windows erano di fatto un programma che girava sopra MS-DOS. Nei sistemi Unix, invece, i comandi a disposizione dell'utente
(come , , ) non sono parte del sistema operativo: sono normali programmi, che si appoggiano ai servizi del SO; lo stes‐
ls cp mkdir
so vale per le varie interfacce grafiche disponibili, che si possono installare, sostituire o rimuovere senza modificare il sistema opera‐
tivo vero e proprio.
Il kernel
In ogni caso, in qualunque sistema operativo è di solito possibile individuare un "cuore", propriamente detto kernel (nucleo), che
svolge funzioni molto simili in qualsiasi sistema. Tali funzioni sono:
la gestione dei programmi in esecuzione;
la gestione della memoria principale;
la gestione della memoria secondaria.
DEFINIZIONE
Il kernel (nucleo) è la parte del sistema operativo sempre presente in memoria e in esecuzione con i massimi privilegi, che si oc‐
cupa della gestione dei programmi in esecuzione, della memoria principale e della memoria secondaria. Tutto il resto (comandi,
interfacce grafiche, utilità di sistema) è costruito sopra il kernel.
L'obiettivo del corso è proprio studiare il funzionamento del kernel di un generico sistema operativo. Non studieremo quindi un siste‐
ma specifico in ogni dettaglio, ma i principi e le soluzioni comuni: tutti i sistemi operativi "general purpose" diffusi (Windows, ma‐
cOS, Unix, Linux, Solaris, ...) adottano soluzioni simili a quelle che vedremo, pur con differenze di implementazione.
1.2 Architetture single-core e multi-core
Dal processore singolo ai core
All'incirca fino alla fine degli anni '90, termini come "processore" o "CPU" indicavano una singola unità per l'esecuzione delle istru‐
zioni macchina. Un processore di questo tipo poteva eseguire le istruzioni di un solo programma alla volta, proprio come le archi‐
tetture studiate nel corso di Architetture degli elaboratori. In realtà i processori di fascia alta dell'epoca (come i Pentium, gli AMD e i
PowerPC) erano già in grado di eseguire in parallelo 3 o 4 istruzioni macchina, grazie a tecniche come la pipeline e l'esecuzione su‐
perscalare; ma si trattava sempre di istruzioni appartenenti allo stesso programma. Dal punto di vista del sistema operativo, quindi,
in ogni istante c'era un unico programma in esecuzione.
Dai primi anni 2000, però, l'aumento di prestazioni del singolo processore ha subito un sensibile rallentamento. Per decenni le pre‐
stazioni erano cresciute quasi esponenzialmente, grazie all'aumento della frequenza di clock e alla miniaturizzazione dei transistor;
a un certo punto aumentare ulteriormente la frequenza è diventato impraticabile, soprattutto a causa del consumo energetico e del
calore da dissipare, e anche le tecniche per estrarre parallelismo da un singolo flusso di istruzioni hanno raggiunto i loro limiti.
Per contrastare questo rallentamento, e poter continuare a offrire sul mercato computer dalle prestazioni sempre più elevate, si è co‐
minciato a progettare CPU costituite da due processori affiancati sullo stesso die (la stessa "fettina" di silicio). I due processori
hanno cambiato nome: ciascuno viene chiamato core, e il sistema nel suo complesso viene indicato come processore dual-core. Con
il tempo e i miglioramenti tecnologici si è poi passati a processori quad-core e oltre, fino a 16 core e più, usati normalmente in tutti i
nostri dispositivi elettronici: non solo computer, ma anche smartphone, tablet, fotocamere e così via.
Oggi, quindi, quando si parla di processore o CPU si intende quasi sempre un processore multi-core: dual, quad o con ancora più
core. Un processore a N core è in grado di eseguire simultaneamente (cioè in un vero parallelismo fisico) le istruzioni di N program‐
mi diversi, uno per ciascun core. Per mantenere uniforme la terminologia, un processore costituito da un'unica unità di esecuzione
delle istruzioni sarà detto processore single-core.
Memoria e cache condivise
Nei moderni processori multi-core tutti i core condividono la stessa memoria principale. Questo significa che un programma in
esecuzione può indirizzare le stesse celle di memoria indipendentemente dal core su cui sta girando: se il sistema operativo sposta
un programma da un core a un altro, il programma continua a vedere esattamente gli stessi dati agli stessi indirizzi.
Di solito, inoltre, tutti i core condividono anche un livello di cache. Ciò offre notevoli vantaggi per lo scambio veloce di informazio‐
ni tra i core: se un core scrive un dato che un altro core deve leggere, il dato può passare attraverso la cache condivisa, senza dover
arrivare fino alla memoria principale, che è molto più lenta. Una tipica organizzazione è quella in figura: un processore dual-core,
con due core sullo stesso chip, due livelli di cache privata per ciascun core (L1 e L2) e un livello di cache condiviso (L3).
+-------------------- chip (die) ---------------------+
| +-------------+ +-------------+ |
| | core 0 | | core 1 | |
5
| | (registri) | | (registri) | |
| +-------------+ +-------------+ |
| | cache L1/L2 | | cache L1/L2 | |
| +------+------+ +------+------+ |
| | | |
| +------+-----------------------------+------+ |
| | cache L3 (condivisa) | |
| +---------------------+---------------------+ |
+-------------------------|---------------------------+
| bus di sistema
+-----------+-----------+
| memoria principale |
+-----------------------+
Wafer, die e package
Qualche termine sulla produzione dei processori. Il wafer è una piastra circolare di silicio sulla quale vengono prodotti contempora‐
neamente centinaia di processori. Ogni rettangolino del wafer, il die, contiene un singolo processore (che a sua volta può contenere
uno o più core). Il die viene tagliato dal wafer e inserito in un supporto di plastica e ceramica detto package, dotato dei piedini o
contatti che permettono di collegarlo alla scheda madre. Un processore può quindi essere single-core (come i vecchi Pentium 4) op‐
pure avere 2 o più core sullo stesso die, come gli Intel i3, i5, i7 e i9.
Che cosa assumeremo nel corso
Nel corso studieremo le caratteristiche fondamentali dei sistemi operativi tipici di un generico computer moderno. Questi computer
sono sistemi single-core oppure multi-core, in cui almeno due (ma spesso più di due) core condividono lo stesso bus di sistema e la
stessa memoria principale (e, in parte, anche la cache).
Concettualmente, però, non c'è una grossa differenza tra un sistema operativo per computer single-core e uno per computer multi-
core. Semplicemente, un SO progettato per gestire più core, quando questi sono disponibili, li sfrutta distribuendo l'esecuzione dei
programmi tra i vari core. Per semplificare la discussione, nel seguito assumeremo sempre implicitamente che il sistema opera‐
tivo giri su un computer con processore single-core, cioè con una sola unità di esecuzione dei programmi. Quando sarà opportu‐
no faremo osservazioni specifiche per il caso multi-core (ad esempio parlando di scheduling e di sincronizzazione).
Altri tipi di sistemi operativi
Oltre ai sistemi operativi che girano sui nostri computer esistono altri tipi di sistemi operativi, sviluppati per hardware più specifico.
Anche nei tablet, negli smartphone, nelle foto e videocamere, nei router e nelle console per videogiochi girano sistemi operativi, con
caratteristiche più o meno simili a quelle dei SO per computer, ma a volte
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.
Scarica il documento per vederlo tutto.