Estratto del documento

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

Anteprima
Vedrai una selezione di 20 pagine su 121
Appunti di teoria su Sistemi operativi Pag. 1 Appunti di teoria su Sistemi operativi Pag. 2
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 6
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 11
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 16
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 21
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 26
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 31
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 36
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 41
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 46
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 51
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 56
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 61
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 66
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 71
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 76
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 81
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 86
Anteprima di 20 pagg. su 121.
Scarica il documento per vederlo tutto.
Appunti di teoria su Sistemi operativi Pag. 91
1 su 121
D/illustrazione/soddisfatti o rimborsati
Acquista con carta o PayPal
Scarica i documenti tutte le volte che vuoi
Dettagli
SSD
Scienze matematiche e informatiche INF/01 Informatica

I contenuti di questa pagina costituiscono rielaborazioni personali del Publisher maurizio.costa.03 di informazioni apprese con la frequenza delle lezioni di Sistemi operativi e studio autonomo di eventuali libri di riferimento in preparazione dell'esame finale o della tesi. Non devono intendersi come materiale ufficiale dell'università Università degli studi di Torino o del prof Botta Marco.

Domande e risposte

Hai bisogno di aiuto?
Chiedi alla community