Chiamate funzioni ...................................

13
Sommario Interrupt Vector ...................................... 13
Processi Unix ............................................. 2
Interrupt Hardware ................................. 13
Architettura ............................................... 2
Interrupt Software .................................. 13
Iterazione con utente ................................ 2
Polling ..................................................... 13
Memoria Unix ........................................... 2
Stati esecuzione processore User/Kernel14
Protezione ................................................. 2
Differenza chiamata funzione/system call
File system................................................. 2 ................................................................ 14
Accesso al file in unix ................................ 3 Buffering nei sistemi periferici ................ 14
PCB Process Control Block ........................ 3 File System .............................................. 15
Thread e Linux ........................................... 3 ACL Access Control List ........................... 15
Direct Memory Access DMA ..................... 3
Processi ..................................................... 4
Cambio contesto ....................................... 4
Cosa succede quando switch processo ..... 4
Sistemi operativi in Tempo Reale ............. 4
Spooling..................................................... 4
Scheduling ................................................. 5
Algoritmi.................................................... 5
Kernel monolitico, modulare, a livelli e
microkernel ............................................... 5
Sistemi Batch ............................................. 5
Sistemi Transazionali ................................. 5
Gestione Memoria .................................... 6
Algoritmo x ave max processi eseguiti ...... 6
Segmentazione della memoria ................. 7
Paginazione Memoria ............................... 8
Gestione Page-fault................................... 8
Algoritmo LRU Last Recently Used ............ 8
Algoritmo FIFO .......................................... 8
Second Chance .......................................... 8
Segmentata paginata ................................ 9
Thread ....................................................... 9
Starvation e metodi risoluzione ................ 9
Mutua esclusione e Semafori.................. 10
Produttore/Consumatore soluzione
tramite semafori ..................................... 10
Deadlock.................................................. 11
Timer ....................................................... 11
Classificazione I/O varia modalità ........... 12
Gestione I/O ............................................ 12
Sottosistema I/O ..................................... 12
Dischi e scheduling .................................. 13
Interrupt .................................................. 13
Processi Unix Iterazione con utente File system
Famiglia unix processi Utente interagisce tramite processore dei Struttura dove vengono memorizzati e
comandi (shell) impartendo direttive gestiti i file
Gestione time sharing + stati
Vocabolario specifico anche se ad oggi Le astrazioni sono file e directory
PCB = Process Structure + User Structure
consolidata interfaccia grafica
Caratteristica principale di unix omogeneità
Modalità accesso processi
Schell acquisisce comandi tramite linea di dove ogni risorsa rappresentata nel file
Modello locale – spazio indirizzamento comando o file script system sotto forma di file

Iterazione cooperazione solo con messaggi Comandi classificati in: File ordinario insieme di info effettivamente
allocate in memoria di massa
Sincronizzazione mediante segnali Interni, se rappresentano una particolare
funzione interna allo shell File speciale rappresenta un dispositivo
Segnale evento inv. da mittente a 1 o + dest. fisico
Esterni, presenti nel sistema sotto forma di
Gestione segnali + kill file eseguibili File directory rappresenta concetto astratto
Pipe hanno spazio limitato di directory
Memoria Unix
Int fork(void) Gestione segmentazione paginata Struttura gerarchica rappresentato da grafo
aciclico diretto
Terminazione processi Spazio indirizzamento processo segmentato
Ad ogni istante a ogni utente è associata una
Void exit(int status) status permette al Allocazione segmenti gestita con directory che ne rappresenta la posizione
processo che termina di comunicare al paginazione a domanda dentro la struttura ad albero
padre le informazioni sintetizzate in un
Fatta dal kernel con il processo pagedaemon In unix il nome di un file rappresenta il
valore intero sul suo stato di terminazione
cammino che bisogna percorrere per
Collegamento tra pagine fisiche e logiche
int wait(int *status) status è l’indirizzo della arrivare al file
mantenuto nella tabella delle pagine
variabile nella quale verrà eventualmente
memorizzato lo stato di terminazione del Nome relativo dalla posizione corrente fino
Kernel mantiene descrizione stato
figlio e il risultato ottenuto è il pid del al file
allocazione memoria dentro core map
processo terminato Nome assoluto dalla directory di
Elementi core map rappresenta una pag.
appartenenza fino al file
Architettura fisica che contiene le info relative a essa
L’architettura Unix è a livelli, ognuno dei File system trova allocazione in un
La sostituzione pagine si basa sull’algoritmo
quali presenta una specifica interfaccia dispositivo fisico
di second chance
Livello Hardware; la parte fisica della Bootblock: allocato a indirizzo prefissato e
Pagedaemon attiva l’algoritmo se num. Pag.
macchina contiene il prog. Di inizializzazione del
fisiche libere < valore di soglia (lostfree)
sistema che sarà eseguito in bootstrap
Livello Il Sistema Operativo; questo livello è
Se pagedaemon fallisce interviene lo
monolitico nella maggior parte delle Superblock: descrive allocazione file system
swapper
realizzazioni, l’interfaccia del sistema contiene limiti 4 regioni + puntatore blocchi
operativo mette a disposizione le system Per rilevare questa situazione ci sono 2 liberi + puntatore i-node liberi
calls, ovvero dei servizi a disposizione del parametri: minfree num. Minimo pag.
Datablock: rappresenta zona disco
programmatore che vengono eseguiti fisiche libere, desfree num. Medio pag. in
effettivamente disponibile per la
nell’ambito del kernel. Molto spesso questi una data unità di tempo
memorizzazione dei file, contiene blocchi
“servizi” riguardano specifiche operazioni su
Swapper interviene se num pag fisiche liberi e allocati, quelli liberi organizzati in
processi e/o files
libere<minfree e se num medio pag. libere una lista collegata loro indirizzo contenuto
Livello Librerie standard; che mettono a nell’unità di tempo<desfree nella superblock
disposizione un’interfaccia C per le chiamate
Protezione i-list: contiene vettore tutti descrittori file,
di sistema
Unix sistema multi utente con specifiche directory e dispositivi presenti nel file
Livello Utilità di sistema; programmi politiche di protezione per riservare accesso system
applicativi che offrono all’utente specifici modifica dei file a specifici utenti A ogni file è associato un descrittore (i-node)
servizi
Utente accede mediante coppia user e pass identificato univocamente da un i-number,
Livello Utente; che si avvale dell’interfaccia attributi associati: tipo,proprietario e
utente nell’uso del calcolatore Allocazione risorse basato su ACL con gruppo,dimensione,data,link,bit
sintetizzazione 9bit di protezione protezione,vettore indirizzamento contiene
insieme di indirizzi x indirizzamento dei
3bit user, 3bit group, 3bit others
blocchi di dati dove sono allocati i file
+ altri 3 bit= set user id, set group id, sticky
Metodo allocazione a indice a più livelli di
bit
indirizzamento
Accesso al file in unix Thread e Linux Variabili condizione strumento che permette
Ogni file in unix organizzato come sequenza Differenza tra unix e linux gestione dei ai thread di sospendere la propria
di byte con metodo accesso sequenziale thread esecuzione in attesa che venga soddisfatta
una determinata condizione, associata coda
A ogni file aperto associato i/o pointer che Gestiti a livello kernel e in linux tutto è
dove processi possono sospendersi con wait
indica il prox elemento a cui accedere thread
e risvegliarsi con signal, a differenza dei
A livello globale il kernel mantiene: Processo unix in linux diventa un thread che semafori non hanno uno stato, si realizza
condivide memoria con gli altri con thread_cond_t e inizializzata con
tabella dei file aperti di sistema TFAS thread_cond_init parametri condizione da
contiene un elemento x ogni file aperto nel Si usa primitiva clone con la quale il realizzare e indirizzo struttura per attributi
sistema e l’i/o pointer programmatore dichiara lo spazio di della condizione, verifica delle condizioni
indirizzamento da mettere in condivisione richiede accesso a sezioni critiche con prob.
tabella dei file attivi TFAT contiene i-node
tra padre e figlio Di mutua esclusione quindi si associa
dei file aperti
Primitiva clone tipica di linux non sempre un semaforo mutex per garantire
tabella dei file aperti del processo TFAP risoluzione di tali problemi
considerata portabile per questo mejo usare
organizzata a vettore ogni elemento
primitive standar e portabili presenti in
individuato da un indice detto file descriptor Direct Memory Access DMA
libreria pthreads che segue regole POSIX
I trasferimenti di dati tra una periferica e la
accesso file tramite primitiva open che
Ogni programma in esecuzione memoria avviene generalmente passando x
prende come argomento il nome del
rappresentato da 1 o + thread individuati da la cpu, le periferiche veloci come un unità
file,modalità con cui aprirlo + parametro
identificatore TID disco possono accedere direttamente alla
opzionale se crea nuovo file con conseguenti
memoria senza il coinvolgimento della cpu
12bit di protezione Thread creato con primitiva pthread_create
utilizzando la tecnica del DMA dove un
richiede puntatore alla variabile che
Se open successo i/o pointer posiziona dispositivo chiamato DMA Controller prende
raccoglierà nuovo thread, parametro per
primo byte da leggere il controllo del bus degli indirizzi e i dati da
specificare eventuali attributi, puntatore
trasferire vengono memorizzati o letti in
Operazione ultimata chiamata primitiva contenente codice del nuovo thread,
maniera sequenziale partendo da un punto
close che salverà il file su disco e lo rimuove puntatore eventuale vettore che contiene
prefissato in fine il DMA comunicherà alla
dalle tabelle elencate prima parametri da passare al nuovo thread
cpu la fine del trasferimento x mezzo di uno
Accesso vero e proprio al file avviene Pthread_create restituisce 0 se successo specifico segnale di interruzione.
mediante primitive read e write richiedono altrimenti mex di errore
Il DMA è quindi collegato alla periferica
come argomento il file descriptor, area tramite un interfaccia e alla cpu con il bus e
Thread può essere terminato primitiva
buffer dove mettere dati letti e numero byte
pthread_exit unico parametro puntatore alla ha 2 compiti
da leggere
variabile che contiene eventualmente valore
1.comunicare con il programma e la
restituito
PCB Process Control Block periferica x ricevere ordini
I processi sono molto importanti x un SO e la Sospensione tramite pthread_join 2
2.rendere operativi tali ordini
loro gestione deve essere molto oculata per parametri TID e puntatore dove verrà
questo motivo ogni processo presenta un salvato il valore restituito Il processore attraverso un programma CPU
apposito descrittore chiamato PCB tutti Driver comunica con il DMA Controller
organizzati in una tabella dei processi la Per problemi sincronizzazione libreria
seguendo un determinato protocollo x lo
quale raccoglie tutto quello che è utile pthread mette a disposizione 2 strumenti
scambio di info, il CPU Driver ha sempre
nell’identificare e gestire ogni singolo Mutex particolari semafori che accettano l’iniziativa nel comunicare o far finire le
processo come per esempio: come valore solo 0 o 1 e permettono operazioni di I/O mentre il DMA Controller
gestione della mutua esclusione definiti con può solo eseguire i comandi e comunicare
1.il pid cioè il nome del processo
pthread_mutex_t rappresenta stato del alla cpu la fine del trasferimento, la
2.lo stato del processo
semaforo e la coda dei processi nella quale memoria ha quindi il compito di
3.la modalità con cui viene gestito
verranno sospesi i processi in attesa di memorizzare i dati durante le operazioni di
4.informazioni sul modo di memorizzare un
mutex libero, quando inizializzato mutex input e renderli disponibili alla periferica
processo
definito libero o occupato con durante un operazione di output
5.il contesto del processo
6.le risorse che deve e può utilizzare pthread_mutex_init, sono possibili
7.l’identificazione del processo successivo concettualmente solo operazioni locking e
unlocking equivalenti alla wait e signal, con
lock il processo trova mutex occupato e si
sospende nella coda dedicata, con unlocking
viene riattivato il processo con maggiore
priorità in coda
Processi Cambio contesto Sistemi operativi in Tempo Reale
Struttura dinamica visa come sequenza stati Si ha un cambio contesto quando si passa da I sistemi Real-Time hanno il compito di
attraverso i quali un calcolatore passa per un processo a un altro dover gestire le situazioni reali percependo
eseguire un programma tramite dei sensori dall’ambiente esterno
Rallenta la cpu con conseguente overhead
quelle che sono le valutazioni fisiche
Esempio prog. Minimo comun divisore cioè tempo che il microprocessore impiega
rielaborandole tramite il SO e dandone una
nel context switch per i salvataggi nei dovuti
Virtualizzazione processori permette ai risposta tramite specifici attuatori
registri dovuti a imminenti cambiamenti
processi di percepirne la presenza di un
I sistemi Real-Time hanno dei task ovvero
processore dedicato Le fasi sono 4:
degli obbiettivi da eseguire in un
Stati processi 1.viene salvato lo stato di esecuzione del determinato tempo chiamato deadline
processo dentro il suo descrittore (chiamato
Iterazioni processi: cooperazione buffer I Sistemi Real-Time si dividono in 2 categorie
salvataggio stato)
produttore consumatore che dopo politiche
Hard-Realtime: dove le deadline devono
di sincronizzazione 2 processi non entrano 2.il PCB viene inserito nella coda dei processi
essere rispettate in maniera stringente
mai in conflitto, competizione dove i pronti o bloccati dove se il contesto dovuto
altrimenti il sistema andrà in blocco (fare
processi competono per medesima risorsa è a sospensione processo va nella coda dei
esempio assetto di volo aereo)
opportuno prevedere delle politiche di processi bloccati se invece dovuto a revoca
mutua esclusione esempio processi che va nella coda dei processi pronti Soft-Realtime: dove le deadline sono meno
devono stampare stringenti e quindi permettondo qualche
3.Viene trovato il nuovo processo da
fallimento nel raggiungere la deadline, il
Cattiva valutazione problemi iterazioni porta mettere in esecuzione tramite gli algoritmi
programma andrà cmq avanti anche se con
interferenze tra processi risolti in maniera di scheduling
un calo di prestazioni generali
diversa a seconda della tipologia:
4.viene caricato il contesto del nuovo
La gestione dei task avviene tramite le
ambiente globale risorse a disposizione di processo nei registri del
priorità date ai vari processi che possono
tutti i processi e la gestione avviene tramite processore(chiamato ripristino stato) opera
essere statica o dinamica
semafori con primitive wait e signal sulla base dell’algoritmo FIFO se esiste una
coda per tutti i processi pronti o bloccati o Statica: se la decisione di schedulazione è
ambiente locale risorsa posseduta da un
utilizzando la info della priorità nel caso di presa prima che il sistema inizi l’esecuzione
singolo processo con cui interfacciarsi per
più code dei processi richiedendo quindi in anticipo le
chiederla e ottenerla, comunicazione tra
informazioni sul lavoro da fare e le scadenze
processi con primitive send e recive Complessità dipende dall’architettura
da rispettare, algoritmo usato Rate-
hardware
comunicazioni avvengono in maniera Monotonic RM la quale assegna le priorità in
diretta: mittente e destinatario vanno Comporta aggiornamento di tutte le base alla durata del ciclo di lavoro
espressamente specificati nella send e strutture che rappresentano le risorse usate
Dinamica: se la decisione di schedulazione è
recive, indiretta: i messaggi inviati a una dai processi soprattutto x quanto la
presa durante l’esecuzione dei processi,
porta detta mailbox gestita dal SO e memoria che possono influenzare
l’algoritmo usato Earliest Deadline First EDF:
accessibile medianti specifiche chiamate di l’efficienza del meccanismo
dove lo scheduler seleziona come primo
sistema
Per rendere più efficienti i SO introdotto processo quello con la distanza minima dalla
la send può essere asincrona: consente al concetto di thread che non possedendo sua deadline, e ogni volta che un nuovo
processo di continuare la sua esecuzione risorse proprie possono essere creati e processo entra nella coda dei processi pronti
subito dopo l’esecuzione della send, distrutti più facilmente vengono riesaminate tutte le deadline al fine
sincrona dove il mittente è bloccato fino a di rideterminarne le priorità
Linux vantaggio basso costo computazionale
quando il destinatario non riceve il
per cambio contesto Spooling
messaggio
Esiste una specie di contemporaneità tra
la recive può essere bloccante: blocca il Cosa succede quando switch processo l’esecuzione di un programma e le
processo fino alla ricezione di un mex, non Nel cambio contesto si salvano i registri che operazioni di I/O diminuendo così i tempi di
bloccante: consente la prosecuzione del contengono i dati che riguardano il processo attesa, grazie alla tecnica di spooling che
lavoro anche in assenza di messaggi nel suo descrittore e poi si caricano i dati del consente di immagazzinare
descrittore del processo che deve essere temporaneamente una grande quantità di
eseguito nel processore dati su un unità di memoria di massa e
inviarli inseguito alla periferica che li deve
usare.

Il calcolatore in questo modo effettua lo

spooling di molte pagine di stampa potendo
tornare subito ad essere disponibile x altro
lavoro mentre il software di spooling si
occupa di inviare le pagine alla stampante.
Scheduling processi di natura diversa viene gestita dalle privilegiato e livello utente, questi sistemi
Il SO sceglie i processi da mettere in code multiple di stati per i singoli processi in impongono il continuo uso di chiamate di
esecuzione attraverso algoritmi di modo da gestire le schedulazione in modo + sistema per mettere in connessione i vari
scheduling, esistono 3 tipologie efficiente processi con un conseguente calo
dell’efficienza generale
Scheduling lungo termine sceglie i processi Kernel monolitico, modulare, a livelli e
dalla memoria secondaria da inserire nella microkernel Livello Privilegiato: permette gestione di
coda dei processi pronti tenendo conto degli Kernel costituisce il nucleo fondamentale del tutto quello presente a livello kernel
sviluppi futuri che si hanno con la scelta di SO è sostanzialmente un programma che ha Livello Utente: accesso generico agli utenti
uno rispetto a un altro il compito di fornire ai processi in che non hanno possibilità di gestire
Scheduling medio termine si occupa della esecuzione un accesso sicuro e controllato questioni e meccanismi tipici del kernel e
gestione dei processi posti in stato swap all’hardware, potendo esistere + di un obbligati a usare le chiamate di sistema x
processo si occupa di fornire anche il tempo- avvalersi delle strutture fisiche
Scheduling breve termine si preoccupa di macchina e di accesso all’hardware a ciascun
scegliere quale processo in coda porre in programma Sistemi Batch
esecuzione Primi So inizi anni 60 furono i sistemi Batch
Monolitico: nessuna particolare divisione
I processi si dividono i 2 categorie dall’inglese pacco
interna ma solo chiamate di sistema in
linguaggio assembler x rapportarsi Prevedevano di dare a un utente preposto
Preemptive: prevedono la possibilità di
direttamente con l’hardware, adatta solo a un pacco di schede perforate che le inseriva
rilasciare le proprie risorse in caso di
piccoli sistemi operativi come MS-DOS nel calcolatore in un'unica trance dove il
esigenza togliendo ad esempio il tempo di
cpu a i processi colpiti da interruzione per primo antenato dei SO chiamato MONITOR
Modulari: sistemi divisi in moduli ognuno
fare spazio a quelli più utili in quel momento che attraverso dei cicli riusciva a gestire
con una propria interfaccia che ne specifica
l’evoluzione dei programmi aumentandone
la funzionalità, potendo così modificare i
Non-Preemptive: tipici dei sistemi batch, il l’efficienza anche se non di molto
vari moduli senza intaccare l’interfaccia non
SO non è in grado di togliere il tempo di cpu
modificare quindi l’intero programma. I Problemi: allontanamento dell’utente dal
ai processi che rilasceranno
primo sistemi vennero divisi in due moduli calcolatore con una conseguente
spontaneamente la cpu finito il loro lavoro
ovvero il kernel la quale è il nucleo con diminuzione di capacità di debugging, altro
Algoritmi l’insieme di programmi di utilità che problema dovuto alla sequenzialità in
First Come First Served FCFS: semplice da potevano essere eseguiti solo in modalità quanto il calcolatore eseguiva i programmi
implementare, lavora come se fossimo privilegiata, e lo shell dove c’era tutto quello in maniera sequenziale senza tener conto
difronte a una coda e il primo arrivato è il che poteva essere eseguito in modalità non degli effettivi tempi di esecuzione dei
primo a essere servito, svantaggio privilegiata la quale si è poi evoluta da programmi
sequenzialità, esempio processo semplice un’interfaccia puramente testuale ad una
arrivato in coda per ultimo con interfaccia grafica con elementi cliccabili Sistemi Transazionali
a schermo Usati in applicazioni gestionali che
Shortest Job First SJF: si valuta il tempo di necessitano di basi di dati garantendo il
esecuzione del singolo processo cioè chi Livelli gerarchici: dove il compito principale è
rispetto delle proprietà ACID ovvero
impiega meno tempo per completare il quello di diminuire il numero di
interconnessioni fra i vari moduli di sistema
atomicità, consistenza isolamento e
proprio obbiettivo, svantaggio è il dover durabilità, il SO deve essere in grado di
conoscere in anticipo i tempi di esecuzione in modo da rendere la programmazione +
dei processi cosa lontana dalla verità semplice, le tecniche usate sono il top-down gestire i malfunzionamenti anche di rete
la quale permette di dividere il sistema garantendo l’atomicità delle operazioni in
Shortest Remaining Time First SRTF: si valuta software nei suo componenti principali modo da prevenire inconsistenze nei dati
in maniera preemptive l’algoritmo SJF dove trovandone le funzionalità a prescindere dai salvati implementando la full tollerance
se entra nella coda dei processi pronti un dettagli realizzativi, l’altra tecnica è quella
I SO connessi permanentemente alla rete
nuovo processo che necessità di un tempo bottom-up la quale partendo dal livello
possono essere definiti come:
minore per l’esecuzione con aumento di macchina ne definisce alcuni moduli
priorità scala la fila per essere eseguito il software che implementano funzionalità Di Rete: dove uno o + nodi fanno da server
prima possibile, lo svantaggio dovuto alla non disponibili direttamente dall’hardware. per una moltitudine di nodi client dotati di
revocabilità porta a continui cambi contesti Spesso si usano entrambe le tecniche x SO di rete, i client scaricano i file o simulano
con aumenti di overhead sfruttare i pregi di entrambe lo scaricamento dei file facendoli apparire
come locali
Round Robin RR Microkernel: dove i meccanismi sono
concentrati nel kernel mentre le politiche Distribuiti: dove tutti i nodi usano lo stesso
Schedulazione Su Base Prioritaria: si ottiene
assegnate ai vari programmi semplificando SO e l’user di qualsiasi nodo vede un singolo
applicando ai singoli processi delle priorità di
in questo modo il kernel che dato la maggior SO senza sapere dove viene di volta in volta
natura statica o dinamica, permettendo di
complessità dei SO ne risultava troppo eseguito il programma
prevenire il fenomeno di starvation
affollato di informazioni. Questa divisione ha
Schedulazione a Code Multiple: si usa nei SO consentito la diffusione delle doppie
più complessi dove la coesistenza di + esecuzioni del processore cioè modo
Gestione Memoria Segmentata: i segmenti di codice dati e Allocazione Worst Fit: il processo viene
Nel calcolatore ram e cpu fondamentali per stack possono essere allocati in maniera non allocato nella partizione + grande che è
l’esistenza dei processi e programmi contigua non essendoci nessun vincolo tra i disponibile
segmenti, la modalità segmentata genera 3
Esistono 2 tipi di risorse di sistema Partizione Multiple: considerato che x le
spazi virtuali tutti che partono dall’indirizzo
partizioni fisse e variabili i processi non
Preemptive: prevedono la possibilità di 0 (es. Spazio 0 x codice, spazio 1 x dati e
condividono segmenti di memoria si ricorre
rilasciare le proprie risorse in caso di spazio 2 x stack)e a questo punto il
alle partizioni multiple. Si divide lo spazio
esigenza togliendo ad esempio il tempo di caricatore potrà allocare i 3 spazi in 3
virtuale per rendere indipendente il codice
cpu a i processi colpiti da interruzione per porzioni distinte non necessariamente
condiviso dalle componenti private facendo
fare spazio a quelli più utili in quel momento correlate tra loro, ovviamente il caricatore
questo si potrà condividere segmenti di
dovrà tenere conto delle posizioni dei
Non-Preemptive: tipici dei sistemi batch, il memoria tra processi
segmenti per calcolare gli indirizzi fisici (es.
SO non è in grado di togliere il tempo di cpu LOAD(1,16))
ai processi che rilasceranno Algoritmo x ave max processi eseguiti
spontaneamente la cpu finito il loro lavoro Quando spazio virtuale di un processo deve Shortest Job First SJF: si valuta il tempo di
essere allocato in memoria fisica si cerca esecuzione del singolo processo cioè chi
Gestione memoria riassume 4 operazioni una partizione in grado di contenerla e una impiega meno tempo per completare il
fondamentali: volta allocato manterrà la stessa posizione proprio obbiettivo, svantaggio è il dover
anche in caso di swap, le partizioni possono conoscere in anticipo i tempi di esecuzione
1.rilocazione statica o dinamica
essere: dei processi cosa lontana dalla verità
2.allocazione contigua o non
Fisse: memoria divisa in N+1 partizioni di
3.spazio virtuale unico o segmentato dimensioni fisse, una dedicata e le altre N
sono usate per allocare i processi che di
4.caricamento dello spazio virtuale tutto
solito usano le più piccole partizioni in gradi
insieme o a domanda
di contenerle ma non avendo mai
In un calcolatore esistono vari processi che dimensioni esatta con la dimensione del
devono condividere memoria quindi bisogna processo si creerà una parte non utilizzata
distinguere gli indirizzi virtuali da quelli fisici che prende il nome di frammentazione
e prevedere funzioni che permettono di interna, altro svantaggio se lo spazio virtuale
risalire da una a l’altra tipologia, questa del processo>rispetto alla dimensione di
procedura si chiama rilocazione e la tutte le partizioni sono necessarie tecniche
funzione è detta funzione di rilocazione che di overlay per caricare tutto il processo in
dato un indirizzo virtuale permette di risalire memoria
a quello fisico mediante un offset (Y=F(x)) e
Variabili: partizioni create dinamicamente
la rilocazione può essere:
durante il caricamento del processo.
Statica: tecnica con minor overhead e facile Inizialmente avremmo una partizione x il SO
implementazione, il loader converte gli e una x allocare i processi, quando viene
indirizzi virtuali in fisici al caricamento in creato un processo vi si assegna un area di
memoria, quando un programma è caricato memoria pari al processo e al termine lo
in memoria ogni riferimento è fatto su spazio che si libera può essere compattato
indirizzi fisici, svantaggio il programma una con altre partizioni libere adiacenti,
volta calcolati i suoi indirizzi non potrà svantaggio frammentazione esterna che si
essere riallocato altrove in caso di swap-out verifica quando le dimensioni delle aree
libere non sono sufficienti a contenere un
Dinamica: rilocazione degli indirizzi avviene processo
al runtime del programma, loader
trasferisce il programma in memoria senza Tecnica delle partizioni variabili ha una lista
rilocare gli indirizzi virtuali, il loader al delle partizioni libere che viene allocata
completato il caricamento carica nei registri nello spazio del SO e si usano 3 criteri di
program counter e stack pointer i valori gestione
relativi gli indirizzi virtuali dello stesso. La
Allocazione Fist Fit: il processo viene allocato
cpu ragiona cmq in indirizzi virtuali ma
nella prima partizione libera in grado di
occorre l’MMU per convertire in tempo
contenerla, metodo più veloce ma crea alta
reale gli indirizzi virtuali in fisici
frammentazione
L’organizzazione della memoria virtuale
Allocazione Best Fit: il processo viene
avviene:
allocato nella partizione + piccola in grado di
Unica: il linker genera un unico spazio di contenerlo
memora virtuale contiguo x tutti i segmenti
Segmentazione della memoria L’implementazione della segmentazione a
domanda prevede che al descrittore sia
aggiunto un campo di un bit che indica la
presenza o meno del segmento in memoria

Per rendere + semplice l’implementazione di

eventuali algoritmi di rimpiazzamento
possono essere aggiunti altri campi al
descrittore come:

bit U ovvero di uso settato periodicamente a

Dato che x effettuare la traduzione servono
diversi accessi in memoria uno x accedere 0 via software e a 1 via hardware ogni volta
Prevede la rilocazione dinamica con che si fa riferimento al segmento
alla tabella dei segmenti e uno per accedere
partizioni contigue in seguito a caricamento
a l’informazione richiesta per velocizzare il bit M indica se segmento modificato o meno
unico
tutto è stata introdotta una cache se posto a 0 segmento non modificato e
Lo spazio virtuale diviso in segmenti es. associativa la TLB Translation Lookside quindi non necessario riscriverlo nella swap
codice dati e stack e caricate in altrettante Buffer area quando e se verrà scelto come
partizioni segmento da rimpiazzare
Il TLB contiene da 4 a 16 righe dove si
Rilocazione spazio virtuale a fisico fatto dal memorizzano le corrispondenze segmento
MMU con l’uso di 1 coppia di registri base e virtuale-fisico
limiti per ogni segmento
Ogni riga contiene num. Segmento e coppia
Registro base contiene l’indirizzo iniziale di base-limite degli ultimi segmenti a cui si è
caricamento in memoria fatto riferimento

Registro limite contiene la dimensione del Quando la cpu genera l’indirizzo virtuale
segmento x=(seg,off) si cerca prima nella TLB e solo se
non trovata si accede alla tabella dei
La cpu genera l’indirizzo virtuale segmenti aggiornando la TLB
Si accede alla coppia di registri della MMU STLR registro lunghezza tabella segmenti
associata a quel determinato segmento dove sono caricati il num dei segmenti del
Confronto indirizzo virtuale con contenuto processo
registro limite se>genera eccezione, STBR registro di base della tabella segmenti
altrimenti si prende il contenuto del registro dove è caricato l’indirizzo iniziale della
base e si somma all’indirizzo virtuale già tabella dei segmenti
generato x avere quello fisico
La segmentazione prevede la memoria
Tecnica di segmentazione divide lo spazio
virtuale del processo venga caricata x intero
virtuale in N segmenti dove ogni segmento è in memoria fisica avendo quindi 2 condizioni
associato a un modulo del programma possibili
Non è possibile avere una MMU con numero 1.che il processo quindi tutti i segmenti che
coppie di registri pari ai segmenti compongono la sua memoria virtuale sono
Si usa quindi una tabella dei segmenti con allocati in memoria
campo limite e base + ulteriore campo x i 2.il medesimo processo è stato spostato
diritti di accesso nella swap area, dove è necessario
Coppia base limite costituisce il descrittore aggiungere 2 nuovi stati pronto o bloccato
del segmento ma con spazio virtuale non allocato in
memoria
Il descrittore viene scomposto in 2 parti
segmento ed offset La politica on-demand sulla gestione dei
segmenti prevede che venga caricato in
Il parametro segmento è un intero che memoria solo quando viene generato un
rappresenta il numero di segmento indirizzo virtuale che gli appartiene, la MMU
Il parametro offset è lo scostamento di x genera un eccezione che comunica il
all’interno del segmento stesso segment-fault al processore il quale
manderà in esecuzione l’opportuno handler
che comunicando col gestore della memoria
permette di caricare il segmento richiesto
Paginazione Memoria il campo descrittore di processo relativo alla Second Chance
memoria virtuale contiene 2 informazioni Per la sostituzione della pagina si usa i bit di
uso la quale è uno dei bit di controllo
il numero di pagine virtuali del processo
dell’elemento della tabella delle pagine
l’indirizzo iniziale in memoria della tabella associata a ciascun processo, gli altri bit
delle pagine sono M modifica, R read, W write

vantaggi: maggiore flessibilità di allocazione Il bit U identifica se la pagina è stata

in memoria, nessuna frammentazione recentemente riferita
La paginazione consente di risolvere svantaggio: nessuna corrispondenza tra Ogni volta che la pagina è riferita il bit viene
problema della frammentazione tipica della moduli di un programma e pagine virtuali settato a 1 via hardware
memoria partizionata ovvero livello protezione e condivisione solo
Settato a 0 via software quando non usata
La rilocazione è dinamica con spazio virtuale a livello di pagina e non di singolo modulo
da un po' di tempo
diviso in blocchi di indirizzi virtuali di come nella segmentazione
dimensioni fisse chiamate pagine virtuali Il second chance sostituisce la pagina fisica
Paginazione a domanda: pagine virtuali
con bit U=0
Lo spazio fisico diviso in blocchi di indirizzi caricate solo quando richieste
fisici delle stesse dimensioni di quelle virtuali Se presenti + pagine con bit U=0 allora si
Se la pagina richiesta non è presente viene
chiamati frame o pagine fisiche sceglie quella che è stata caricata in
generato un page-fault e il processo che lo
memoria per prima (FIFO)
L’allocazione delle pagine virtuali nelle ha creato si sospende e il suo contesto
frame è non contigua salvato nel descrittore Se tutte le pagine hanno bit U=1 allora si
sceglie quella caricata per prima
Per ogni processo si mantiene aggiornata in Il SO prima di caricare la pagina richiesta
memoria fisica la tabella delle pagine dove controlla se c’è un frame libero in memoria Le pagine sono organizzate in una coda
troviamo le corrispondenze pagine virtuali- fisica circolare e viene tenuto aggiornato un
fisiche puntatore che chiamiamo vittima
Se non c’è viene cercata una pagina da
Ogni indirizzo virtuale generato dalla cpu è rimpiazzare e si fa usando opportuni Il puntatore vittima punta alla pagina
diviso in 2 parti dove algoritmi come FIFO, LRU, Second Chance successiva a quella rimpiazzata x prima

i bit meno significativi sono l’offset Se la pagina vittima è stata modificata Si controlla il bit U della prima pagina che se
all’interno della pagina virtuale e quindi durante la permanenza in memoria allora =1 non è la vittima ma potrebbe diventarlo
anche della fisica e la sua dimensione bisogna salvarla su disco altrimenti no se nessuna pagina successiva ha il bit U=0 e
dipende dalle dimensioni delle pagine pertanto prima di controllare la pagina
Quindi si carica la nuova pagina e la tabella
virtuali successiva si pone a 0 il bit U
delle pagine viene aggiornata
i bit + significativi costituiscono il numero di Nel caso tutte le pagine avessero bit U=1
Gestione Page-fault allora la pagina da sostituire sarebbe stata la
pagina virtuale e la sua dimensione dipende
Viene gestito dal SO che provvede a caricare prima e la sostituzione sarebbe avvenuta al
dalla dimensione della memoria virtuale
la pagina richiesta da disco in memoria secondo tentativo ecco perché second
quando processo viene schedulato l’indirizzo chance
iniziale della sua tabella delle pagine viene Algoritmo LRU Last Recently Used
caricato nel registro macchina RPRT la quale Usato per rimpiazzare pagina fisica quando
è un registro puntatore alla tabella delle si verifica page fault e non c’è + spazio in
pagine memoria x caricare la pagina virtuale
richiesta dalla swap area alla memoria
il campo pg dell’indirizzo virtuale si usa principale
come indice nella tabella delle pagine dove
si prende l’indice della pagina fisica Il SO sceglie una delle pagine presenti in
corrispondente memoria fisica che tramite l’algoritmo
sceglie quella da + tempo inutilizzata
indirizzo fisico composto ora unendo l’indice
della pagina fisica con l’offset che rimane Si avvicina molto all’algoritmo ottimo ma
uguale non viene mai usato perché complesso da
implementare
il gestore della memoria mantiene
aggiornata la tabella della pagine fisiche Algoritmo FIFO
dove viene riportato se la pagina è occupata Si sceglie quello da + tempo in memoria
o meno nella fortuna ipotesi che sia una di quelle
non più usate altrimenti se creerà un nuovo
la dimensione della pagina virtuale varia da
page-fault molto semplice da realizzare ma
512byte a 4k byte
inefficiente
Segmentata paginata Thread il parallelismo fisico e lo stesso kernel può
Un thread rappresenta un flusso di essere scritto come un sistema
esecuzione all’interno di un processo multithreading.
Svantaggio: efficienza del sistema dovuti ai
All’interno di un processo si possono
tempi che il kernel impiega x il cambio di
definire + di un thread che condividono le
contesto durante la schedulazione che
risorse del processo, risiede nello stesso
risulta essere + complessa dovendo gestire
spazio di indirizzamento e accede agli stessi
la copresenza di processi e thread
dati
Soluzioni Miste: ad esempio quella di solaris
Tecnica di rilocazione dinamica che unisce i Un thread viene creato e distrutto molto +
che combina le proprietà di entrambi i
vantaggi della segmentazione e della facilmente rispetto ai thread e il cambio di
meccanismi, in sostanza i thread utente
paginazione contesto risulta molto + efficiente, inoltre
vengono mappati sopra i thread a livello
viene creato usando la primitiva pthread
Lo spazio virtuale è diviso in segmenti e ogni kernel e quindi non possono essere in
create
segmento paginato in memoria fisica numero superiore a essi, lasciando all’utente
Ogni thread ha associato uno stato di le politiche di scheduling e sincronizzazione.
Caricamento in memoria su domanda
esecuzione (pronto,bloccato,esecuzione), Vantaggi: i thread della stessa applicazione
Ci sono 2 tipi di interruzioni: uno spazio di memoria x le variabili locali, possono essere eseguiti in parallelo su
uno stack, un contesto ed un descrittore processori diversi e la chiamata al kernel da
interruzione di segment-fault quando viene parte di un thread non blocca
richiesto un indirizzo di un segmento la cui La gestione dei thread può avvenire sia a necessariamente il processo che lo ha creato
tabella delle pagine non è in memoria livello utente e sia a livello kernel
Starvation e metodi risoluzione
interruzione di page fault quando la tabella Thread Livello Utente: sono quelli
Per starvation si intende l'impossibilità
delle pagine è caricata in memoria ma la implementati tramite apposite librerie
perpetua, da parte di un processo pronto
pagina virtuale non è stata caricata thread package che contengono funzioni x la
all'esecuzione, di ottenere le risorse sia
creazione,terminazione,sincronizzazione hardware sia software di cui necessita per
Con questa tecnica indirizzi virtuali visti
nonché i meccanismi x il loro scheduling, i essere eseguito. Un esempio tipico è il non
come coppie <seg,off>
thread sono di proprietà e gestione del riuscire ad ottenere il controllo della CPU da
Quando si farà la traduzione viene processo che li ha creati chiamando le parte di processi con priorità molto bassa,
recuperato il descrittore di segmento che apposite funzioni di libreria. qualora vengano usati algoritmi di
contiene 2 campi base e limite Vantaggi: efficienza di gestione in quanto i scheduling a priorità. Per evitare questi
tempi di switching sono ridotti dato che non problemi si possono utilizzare, oltre ad
Il campo base l’indirizzo della tabella delle richiedono chiamate al kernel, grande algoritmi di scheduling diversi, come RR, le
pagine in cui è allocato il segmento flessibilità e scalabilità dato che lo cosiddette tecniche aging dove la priorità di
scheduling può essere modificato e un tale processo aumenta con la
Ogni segmento ha una propria tabella delle permanenza del processo all’interno della
pagine dimensionato volta x volta in base alla
coda dei processi pronti. Ovvero si provvede
specifica situazione, sono portabili inquanto
ad aumentare progressivamente, ad
L’offset viene suddiviso in 2 campi dove i bit realizzate tramite apposite librerie e quindi intervalli regolari, la priorità dei processi
meno significativi sono l’offset all’interno implementate su qualsiasi SO. qualora questi non siano riusciti ad ottenere
della pagina e quelli più significativi sono Svantaggi: se un thread effettua una system le risorse richieste. Questo fa sì che anche
l’indice di pagina virtuale con la quale si può call ad esempio per motivi di I/O oltre che a un processo con la priorità più bassa possa
recuperare il descrittore della pagina sospendere se stesso provoca la potenzialmente assumere quella più alta,
virtuale sospensione anche di tutti gli altri thread riuscendo così ad ottenere, in un tempo
generati dallo stesso processo, non è massimo predefinito, quanto di cui necessita
Se si adotta poi una politica di paginazione a
possibile utilizzare il parallelismo fisico in
domanda si fa un controllo sul bit di
ambienti multiprocessori in quanto generati
presenza ed eventualmente generato un
dallo stesso processo e quindi assegnati a
page fault
uno specifico processo
Altrimenti sommando l’indirizzo base della
Thread Livello Kernel: gestione dei thread
pagina fisica all’offset, letto dal descrittore
affidata al kernel che li gestisce tramite
la quale è presente nei bit meno significativi
chiamate di sistema come tutti gli altri
dell’offset si ottiene l’indirizzo fisico
processi dovendo quindi schedularli,
sospendere e risvegliare assegnandogli le
risorse di sistema, al contrario di quanto
avviene al livello utente se un thread si
sospende un secondo thread generato dallo
stesso processo può naturalmente evolvere
in quando schedulati tra loro in modo
autonomo, questo è uno dei vantaggi, l’altro
è il fatto che è possibile sfruttare al massimo
Mutua esclusione e Semafori La richiesta della risorsa viene fatta dalla Produttore/Consumatore soluzione tramite semafori
Nell’ambito di variabili comuni le operazioni primitiva lock che verifica prima lo stato del Per quanto riguarda la comunicazione tra
effettuate dai processi non devono semaforo, dove se è 0 lo pone a 1 e assegna processi abbiamo un problema noto come
sovrapporsi, queste operazioni rientrano in la risorsa al processo altrimenti rimane in produttore/consumatore dove un processo
delle aree così delicate da essere chiamate attesa che si liberi, questo meccanismo chiamato produttore genera ciclicamente un
sezioni critiche, pertanto è essenziale viene fatto a intervalli regolari garantendo la messaggio e lo deposita in un area di
prevedere la mutua esclusione dei processi mutua esclusione, inoltre in questi momenti memoria ovvero il buffer la quale può
che operano in tali aree in modo da evitare vengono usate le primitive disable e enable contenere un solo messaggio, un secondo
contrasti tra processi ovvero se lavoro io per abilitare o disabilitare le interruzioni in processo chiamato consumatore preleva
non lavori tu. modo che il flusso di esecuzione delle dall’area di memoria il messaggio e lo usa
primitive lock e unlock non venga interrotto
In generale una risorsa preemptive e non- Esistono dei vincoli imposti alle operazioni
e che provochi conseguenze imprevedibili
preemptive può essere usata da un processo dei 2 processi ovvero:
alla volta appunto in mutua esclusione, ad Quando un processo P utilizza la risorsa R a
1.il produttore non può inserire un nuovo
esempio se un processo P ha la risorsa R cui è associato un semaforo la lock dovrà
messaggio se prima il consumatore non ha
nessun altro processo può usare quella precedere la sezione critica e alla fine andrà
prelevato quello esistente
risorsa fino a quando il processo P non la inserita la unlock che rilascerà la risorsa e
2.il consumatore non può prelevare dal
rilascia evitando quindi situazioni di stallo impostando il semaforo a verde cioè risorsa
buffer un nuovo messaggio se prima il
chiamate anche deadlock, va quindi libera, però questo sistema ha 2 grandi
produttore non lo ha depositato
garantita la mutua esclusione per non avere inconvenienti: 1.l’attesa attiva cioè la lock
errori non controllabili impegna inutilmente il processore a La soluzione a questo problema viene
discapito di altri processi, 2.rinvio indefinito imposta usando un ordinamento nelle
La ricerca della soluzione dei problemi legati
in quanto se il semaforo diventa verde prima operazioni dei 2 processi, rendendo
alla mutua esclusione ha portato alla
che venga riesaminato ed un altro processo necessario quindi che i produttori e i
definizione di protocolli di prologo nel senso
richiede la risorsa la otterrà reimpostano il consumatori si scambino dei segnali per
di attività da eseguire in una fase di richiesta
semaforo in rosso, quindi quando si andrà comunicarsi quando un messaggio viene
della risorsa e di epilogo cioè fase di rilascio
poi a testare nuovamente il semaforo lo si depositato o prelevato dal buffer, in questo
della risorsa per renderla nuovamente
troverà ancora occupato dato che la risorsa modo il processo deve attendere il segnale
disponibile ad altri processi
è già stata data ad un altro processo e dell’altro processo per poter compiere la sua
Una delle primordiali tecniche usate nella questo potrebbe verificarsi a tempo azione
gestione della mutua esclusione era la TSL indefinito.
In generale i produttori e consumatori
ovvero Test and Set Lock realizzato tramite
L’informatico Dijkstra diede una nuova possono utilizzare un buffer che può
le primitive Lock e Unlock. interpretazione al concetto di semaforo con contenere + messaggi cambiando quindi le
Anche le primitive lock e unlock hanno dei l’introduzione dell’attesa passiva, un condizioni dette prima ovvero:
problemi, ad esempio se un thread che semaforo può essere modificato da parte
del codice utente solamente con 3 chiamate 1.il produttore non può inserire un nuovo
detiene un lock muore gli altri thread
di sistema: messaggio nel buffer se è pieno
rischiano di aspettare per sempre, quindi in
1.Inizializzazione dove il semaforo viene 2.il consumatore non può prelevare dal
sostanza l’uso di queste primitive porta a inizializzato con valore intero e positivo, buffer se è vuoto
generare errori come la deadlock, a questo 2.Operazione Wait il semaforo viene
proposito sono sempre + in voga gli stili di decrementato. Se, dopo il decremento, il Una soluzione usata per semplicità è quella
programmazione lock-free che permettono semaforo ha un valore negativo, il processo di adottare l’uso dei semafori, la quale è una
metodi si sincronizzazione che non bloccano viene sospeso ed accodato, in attesa di struttura nella quale si possono applicare
processi essere riattivato da un altro processo; solo 2 operazioni primitive ovvero la wait e
3.Operazione Signal il semaforo viene la signal.
Un semaforo è un tipo di dato astratto incrementato. Se ci sono processi in coda,
gestito da un SO multitasking per uno di questi viene tolto dalla coda e posto La struttura dati è quindi costituita da una
sincronizzare l’accesso a risorse condivise in stato di Pronto variabile intera non negativa ad esempio
tra processi. Un semaforo è composto da Con questo meccanismo a ogni risorsa viene s.value con valore iniziale >=0, da una coda
una variabile intera, dalla sua interfaccia e associato un semaforo e una coda destinata dei processi chiamata ad esempio s.queque.
da una coda dei processi chiamata queque a contenere i pid dei processi che l’hanno La primitiva wait viene usata x verificare lo
richiesta stato del semaforo e se il valore è un
Un caso particolare di semaforo molto usato Quando inizializzato il valore del semaforo numero positivo allora il processo viene
è quello binario dove gli unici valori possibili potrà essere letto indirettamente tramite le eseguito e il semaforo decrementato di 1, se
sono 0 e 1, questo tipo di semaforo prende primitive. Sostanzialmente un semaforo
il valore è 0 il processo viene spostato nella
anche il nome di mutex alla quale è possibile quando inizializzato dichiara quante unità di
s.queque associata a quel semaforo. La
associare una risorsa per garantirne la un tipo di risorse sono disponibili e con
l’operazione wait un processo chiede di signal invece serve per risvegliare i processi
mutua esclusione, questo mutex può valore:
riservare un’unità della risorsa, se non sono in sospeso iniziando dal primo processo che
0 che indica semaforo verde e quindi risorsa
disponibili unità il processo viene sospeso da sospeso passa a pronto e così via finché
libera, 1 semaforo rosso e quindi risorsa
per essere risvegliato quando gli sarà la coda dei processi si svuota e il semaforo
occupata.
assegnata l’unità richiesta con l’operazione incrementato di 1
di signal
Deadlock chiedere subito tutte le risorse di cui ha Il ripristino di un blocco critico può essere
Un deadlock o un blocco critico è una bisogno tuttavia lo svantaggio è che bisogna ottenuto abortendo tutti i processi coinvolti,
situazione di stallo che si crea tra 2 processi conoscere in anticipo le risorse di cui lo alcune volte l’abort può essere limitato a un
che possiedono entrambe una risorsa e specifico processo avrà bisogno, la processo alla volta in modo da liberare le
fanno richiesta x averne un’altra mancanza del diritto di revoca può essere risorse e superate la fase di criticità.
superato obbligando i processi che
Un esempio è rappresentato da 2 persone Timer
possiedono già delle risorse glie ne vengano
che vojono disegnare e hanno a disposizione Per consentire la modalità a divisione di
rifiutate delle altre a rilasciare quelle in loro
solo 1 riga e 1 matita che però servono tempo è necessario che il nucleo gestisca un
possesso per ottenere nuovi assegnamenti,
entrambe, potendo prendere un solo dispositivo temporizzatore chiamato timer o
l’attesa circolare invece può essere risolta
oggetto x volta ovvero uno prende la matita clock. I timer sono dispositivi speciali in
impostando delle gerarchie di livelli in modo
e l’altro la riga e se entrambi aspettano di grado di generare interruzioni con cadenze
tale che se un processo appartiene x
ricevere l’oggetto che possiede l’altro verrà periodiche stabilite con le quali si può
esempio al livello d potrà chiedere risorse
a crearsi una situazione di stallo quindi un ottenere la realizzazione di alcuni servizi
del tipo k dove k>d.
deadlock, in buona sostanza è quello che come:
accade anche con i processi anche se la Dinamica: che si basa su particolari algoritmi 1.aggiornamento della data
sequenza di eventi che porta a un deadlock che verificano il soddisfacimento o meno di 2.gestione del quanto di tempo nei sistemi
non è mai prevedibile in modo scontato, una richiesta da parte di un processo che time-sharing
infatti la velocità di esecuzione dei processi può causare un deadlock. Viene usato 3.valutazione dell’impegno della cpu da
rende difficile ogni previsione e inoltre una l’algoritmo Del Banchiere la quale è un parte di un processo
situazione di stallo potrebbe verificarsi sistema per allocare risorse che vengono 4.gestione della system call Alarm
anche dopo anni di corretto funzionamento richieste procedendo come farebbe una 5.gestione dei time-out
a causa di un evento imprevisto. banca dove i processi vengono visti come
clienti che possono chiedere credito alla Come x tutti i dispositivi anche il relativo
Data l’importanza della tematica gli studi driver del timer sarà costituito dalla
banca fino ad un certo limite, e le risorse
hanno portato a definire delle condizioni x struttura del descrittore, dalla funzione di
allocabili viste come denaro. Capiamo quindi
determinare un blocco critico. Bisogna dire risposta alle interruzioni inth offrendo anche
che il sistema come la banca non potrà
che esistono diverse tipologie di risorse ai processi applicativi una primitiva delay
permettere a tutti i clienti di raggiungere il
divise in hardware e software che possono che ogni processo potrà invocare
loro limite di credito contemporaneamente
essere utilizzate dai processi e che devono passandogli come parametro un valore
poiché in quel caso la banca fallirebbe e
rispettare i seguenti protocolli d’uso: intero che starà ad indicare la durata
quindi il sistema fallirebbe non potendo
1.richiesta dove se la risorsa fosse già in uso allocare risorse a sufficienza generando un dell’attesa richiesta dal processo.
tale richiesta potrebbe generare un blocco deadlock
Il controllore del timer contiene oltre ai
del processo richiedente registri di controllo e di stato un array di N
L’algoritmo procede iterativamente
2.utilizzo semafori dove ogni semaforo viene usato x
garantendo le risorse necessarie ai processi
3.rilascio bloccare il corrispondente processo che
che confrontando la loro necessità con
Abbiamo un blocco critico quando si quella delle risorse attualmente disponibili chiama la delay, contiene inoltre un array di
verificano contemporaneamente le seguenti nel sistema posso terminare la loro interi usato per mantenere aggiornato il
condizioni: esecuzione, liberando quindi le risorse che numero di quanti di tempo che devono
aveva precedentemente allocato passare prima che un processo possa essere
1.le risorse possono essere usate da un permettendo quindi all’algoritmo di riattivato.
processo alla volta (mutua esclusione) selezionare un altro processo
2.mentre un processo possiede una risorsa
ne chiede delle altre (principio di possesso e L’algoritmo può essere diviso in 2 parti
attesa) principali ovvero la parte di verifica dello
3.le risorse che sono già assegnate ai stato attuale e la parte di simulazione
processi non possono essere sottratte dell’assegnazione.
(mancanza del diritto di revoca) La verifica dello stato attuale si assicura che
4.esiste un insieme di processi dove l’attesa l’assegnazione di risorse ai processi è un
delle risorse può essere definita circolare assegnazione che fa rimanere il sistema in
uno stato sicuro dove non vi è possibilità di
Possiamo prevenire un deadlock in maniera deadlock
sia statica che dinamica La simulazione dell’assegnazione verrà
Statica: dove in fase di programmazione ci si eseguita quando un processo richiederà
assicura che almeno una delle condizioni delle risorse facendo dunque una
dette prima non sia verificata, si esclude la simulazione sull’assegnazione e farà partire
condizione della mutua esclusione in quanto poi una verifica dello stato per assicurarsi
condizione imprescindibile per la riusabilità che l’assegnazione permetta di rimanere in
delle risorse. Il possesso ed attesa può uno stato sicuro
essere superato obbligando il processo a
Classificazione I/O varia modalità Sottosistema I/O controllare il corretto funzionamento del
Uno dei compiti principale del SO è mettere Un sottosistema di I/O svolge particolari dispositivo, anche questi registri variano a
a disposizione dell’utente una macchina funzioni nella gestione di dispositivi I/O seconda del dispositivo ma in tutti troviamo
virtuale con interfacce facilitate per la come: il bit errore dove se è posto a 1 il dispositivo
gestione di periferiche I/O, in questo funziona e se posto a 0 presenta
1.nascondere al programmatore i dettagli
contesto la programmazione si è malfunzionamenti, troviamo inoltre il bit flag
delle interfacce hardware dei dispositivi
semplificata permettendo di adoperare le la quale se è a 1 il dispositivo a terminato
2.rende omogenea la gestione di dispositivi
API di sistema invece di scrivere in l’operazione e torna in stand-by. I Registri
diversi come ad esempio dispositivi a
linguaggio assembler x ognuna singola dati sono dei buffer nel quale vengono
blocchi, a caratteri e speciali
periferica inseriti i dati in attesa di essere trasferiti
3.gestisce i malfunzionamenti che possono
dalla memoria al dispositivo e viceversa.
Le periferiche possono essere divise in 3 capitare durante un passaggio di dati, questi
2.Livello del Sistema Operativo che si divide
categorie in base alla sorgente: malfunzionamenti possono essere
in due parti, la parte dipendente dove
eccezionali come ad esempio carta finita
1.Quelle che permettono il collegamento troviamo i driver cioè moduli x gestire i
nella stampante, transitori ad esempio
con l’utente come terminali video, mouse e dispositivi e le interruzioni, il driver mette a
interferenza elettromagnetica e infine
tastiera disposizione un interfaccia per attivare il
permanenti come ad esempio la rottura di
2.Quelle che collegano il sistema ad altre dispositivo per l’esecuzione dell’operazione
una testina di lettura di un disco, per ogni
apparecchiature come sensori e attuatore e controllare che durante l’esecuzione non si
malfunzionamento esiste la regola di
3.Quelle che permettono di interfacciarsi verifichino anomalie e eventualmente
risolverlo quanto più vicino alla sorgente che
con utenti o apparecchiature lontane come i attivare le dovute procedure di gestione del
ha generato il malfunzionamento.
modem malfunzionamento e di sincronizzare il
4.definisce i nomi x identificare i dispositivi,
processo applicativo che ha richiesto
Possiamo avere una catalogazione che tiene questa procedura è essenziale x identificare
l’operazione con la fine dell’operazione
conto del trasferimento dati: in modo univoco un dispositivo, un utente
stessa e infine disattivare il dispositivo al
può rinominare il dispositivo a suo
1.Dispositivi a blocchi che registrano dati in termine dell’operazione, la parte
piacimento ma a livello di sistema verranno
veri e propri blocchi di dimensione fisse indipendente è dove invece sono collocate
adottate sempre sequenze numeriche x
come le unità disco specifiche funzioni x la gestione del naming,
l’identificazione della periferica
2.Dispositivi a carattere che non hanno una malfunzionamenti e buffering, e inoltre
5.garatisce la corretta sincronizzazione tra
strutturazione interna come il mouse e viene gestita l’allocazione dei dispositivi
un processo che ha attivato un
tastiera, quindi un dispositivo virtuale dove tramite tecniche di spooling e di dispositivi
trasferimento dati e l’attività del dispositivo
si possono fare operazioni di I/O dedicati.
tramite un confronto che può essere
3.Dispositivi speciali che hanno fini di 3.Livello Utente: dove troviamo l’interfaccia
sincrono dove un processo applicativo attiva
temporizzazione come i timer I/O API ovvero l’insieme delle funzioni e
un dispositivo e si blocca fino alla fine del
librerie con la quale i dispositivi scambiano
trasferimento, asincrona dove un processo
Gestione I/O dati con la cpu.
esecutivo attiva un dispositivo e prosegue
Tramite la modifica del bit cosiddetto di
senza bloccarsi e infine bufferizzazione
start del registro di controllo di un
ovvero delle specifiche aree di memoria
dispositivo possiamo far si che passi da uno
dette tampone che devono immagazzinare
stato di stand-by a quello di start per
dati in attesa del trasferimento, i vantaggi
l’esecuzione del compito ad esso richiesto,
della bufferizzazione sta nell’uso di un buffer
questa gestione può avvenire in 2 modi:
che permette la possibilità di gestire la
1.A Controllo di Programma: dove il differenza di velocità tra il processo e un
processo x ciascun dato da trasferire ne dispositivo.
controlla personalmente la presenza nel
L’architettura di un sottosistema I/O può
rispettivo registro, questa metodologia non
essere descritta su 3 livelli gerarchici in
è adatta i sistemi multiprogrammati in
ordine:
quanto un processo che non po' proseguire
il proprio lavoro continua ad impegnare la 1.Livello Hardware: dove troviamo dei
cpu con i conseguenti sprechi registri che servono alla cpu che controllare i
2.A Interruzione: dove si riserva un dispositivi di I/O e li troviamo tra i bus e il
semaforo a ogni dispositivo e consentendo dispositivo, quindi esiste un controllore per
al medesimo apparato di interrompersi ogni dispositivi, i registri vengono divisi in
tramite l’attivazione dello specifico bit di Registri di controllo la quale sono dei registri
controllo in sola scrittura che servono alla cpu x
attivare un dispositivo e fargli eseguire le
operazioni richieste, sono differenti x ogni
dispositivo ma in tutte troviamo il bit start la
quale solo se è a 1 il dispositivo viene
attivato e inizia il proprio compito. Registri
di stato sono in sola lettura e servono x
Dischi e scheduling Chiamate funzioni Interrupt Software
Possiamo descrivere un disco come una Una chiamata di funzione può essere Un Interrupt software chiamato anche trap
struttura in materiale plastico rivestito da invocata in qualunque punto del è generato da istruzioni assembly simili alle
una sostanza magnetizzabile che a seconda programma, il processore viene istruito per chiamate ai sottoprogrammi con la quale un
della sua magnetizzazione locale identifica il andare a eseguire l’intera procedura e poi processo richiede una system call o
valore di un bit. Un disco oltre aere 2 facce è ritorna al punto in cui si è verificata la supervisor call oppure segnala un exception.
costituito da tracce organizzate in settori e chiamata, il suo funzionamento prevede 2 Questo tipo di interruzioni posso essere
tra una traccia e l’altra esiste un piccolo istruzioni di base una di chiamata Call che abilitate o disabilitate tramite le istruzioni
spazio non magnetizzabile chiamato gap di provoca il salto dalla locazione attuale alla assembly STI Set Interrupt e CLI Clear Set
traccia, possiamo quindi dire che una procedura e l’altra è quella di ritorno ovvero Interrupt
generica posizione sarà rappresentata come la Return che rimanda dalla procedura al
f,t,s dove f=numero faccia, t=numero traccia punto chiamante, entrambe le istruzioni Polling
all’interno della faccia e s=numero settore sono considerate di salto. In pratica quando Il polling o attesa attiva dove il processore
all’interno della traccia, inoltre tutti i settori si invoca una procedura l’istruzione Call testa periodicamente lo stato del dispositivo
vengono trattati come un array lineare di effettua un salto al sottoprogramma x vedere se ha terminato l’operazione di I/O,
blocchi. eseguendo un push automatico del questa attesa risulta essere più dispendiosa
TF=TA+TT contenuto del registro Program Counter in termini di tempo rispetto agli interrupt
TF=tempo medio di trasferimento di un sullo Stack, al contrario la Return provoca che sono di attesa passiva
settore, TA=tempo medio di accesso per una pop dalla cima dello Stack al Program
posizionare la testina all’inizio del settore Counter
considerato e TT tempo di trasferimento dei
dati del settore, TA=ST+RL il tempo medio di Interrupt Vector
accesso è dato dal tempo di seek per Questo vettore è una tabella degli interrupt
posizionare la testina sopra la traccia e contiene gli indirizzi di memoria dei gestori
considerata e rotational latency ovvero delle interruzioni per avviare le specifiche
tempo necessario perché il settore ruotando routine d’interrupt del caso. Ricevuto il
segnale di interruzione la CPU salva nello
si posizioni sotto la testina.
stack la posizione dell’istruzione in
La gestione del tempo come sempre ci
esecuzione dunque accettato l’interrupt la
riporta ad algoritmi di scheduling in modo periferica che lo ha richiesto invia il codice
da poter gestire al mejo gli accessi al disco, per il vettore d'interruzione. In assenza di
in particolare abbiamo: tale segnale la richiesta viene considerata
non accolta. L'abilitazione o meno delle
1.First-Come-First-Served (FCFS); le richieste
interruzioni dipende dal flag IF del registro di
sono servite rispettando il tempo di arrivo, si
flag del processore. Se IF=1 le interruzioni
evita il problema della starvation ma non si sono abilitate, se IF=0 sono disabilitate.
risponde ai criteri di ottimalità L'assembler fornisce due istruzioni a questo
2.Shortest-Seek-Time-First (SSTF); seleziona scopo: STI (SET INTERRUPT) che pone IF=1 e
la richiesta con tempo di seek minimo a CLI (CLEAR INTERRUPT) che pone IF=0.
partire dalla posizione attuale della testina; Occorre comunque, tenere presente che la
può provocare situazioni di starvation CPU resetta IF automaticamente dopo
quando ci sono tante richieste l'accettazione di un’interruzione. Il compito
3.SCAN algorithm (algoritmo di riabilitare le interruzioni, quindi, spetta al
dell’ascensore); la testina si porta ad una programmatore che dovrà inserire in un
estremità del disco e si sposta verso l’altra punto opportuno della sua routine
d'interrupt l'istruzione STI
estremità, servendo le richieste man mano
che vengono raggiunte le tracce indicate,
Interrupt Hardware
fino all’altra estremità. Quindi viene
E’ generato da dispositivi esterni alla cpu e
invertita la direzione
serve x comunicare il verificarsi di un evento
4.C-SCAN (Circular-SCAN); E’ una variante
che generalmente è asincrono, in pratica un
dello SCAN mirata a fornire un tempo di
dispositivo I/O informa la cpu che è
attesa medio (dei processi) più basso
disponibile a fornire o a ricevere dati e il
clock ne segnala la scadenza con un quanto
Interrupt
di tempo
E’ il + facile meccanismo che permette di
interrompere o modificare il normale flusso
delle esecuzione delle operazioni della cpu
al verificarsi di un evento
Stati esecuzione processore User/Kernel Ogni cpu ha il suo set di istruzioni transazione tra la modalità utente e la
Considerando che il SO e i programmi utente privilegiate ad esempio l’istruzione per modalità kernel, le system call vengono
condividono le risorse hardware e software passare alla modalità kernel, istruzioni per il eseguite nello spazio degli indirizzi del kernel
abbiamo la necessità che un errore in un controllo dell’I/O, per la gestione del timer e mentre le chiamate di funzione vengono
programma utente non causi problemi dell’interrupt e le istruzioni STI (set eseguite nello spazio degli indirizzi utente
anche ad altri programmi, infatti x garantire interrupt) e CLI (clear interrupt) che
il corretto funzionamento del SO e x motivi modificano il bit relativo all’abilitazione delle Buffering nei sistemi periferici
di sicurezza i moderni SO hanno 2 modalità interruzioni Una delle funzioni più importanti offerte dal
di funzionamento, una è la modalità kernel livello software indipendente dai dispositivi
In caso di mancanza hardware dual-mode si è quella di fornire x ogni operazione di
usato x lo svolgimento dei compiti richiesti
possono creare gravi problemi in un SO trasferimento dati e in modo del tutto
dal SO tramite le system call dove è possibile
come ad esempio un programma utente che trasparente per il processo applicativo una o
accedere a tutte le risorse del sistema
esegue istruzioni errare può creare un crash più aree di memoria tampone dette anche
mentre l’altra è la modalità utente che viene
del sistema oppure scrivere in locazioni di buffer di sistema destinate a contenere i
usata x la normale esecuzione dei
memoria appartenenti a codice o ai dati del dati durante il trasferimento tra il dispositivo
programmi, in questa modalità non si può
sistema operativo e l’area di memoria virtuale del processo
accedere a tutte le risorse del sistema.
applicativo. Una delle ragioni x la quale
Per stabilire la modalità di funzionamento è Differenza chiamata funzione/system call
vengono usati i buffer di sistema è quella di
presente nel registro Program Status un bit Una chiamata di funzione può essere
far fronte alla notevole differenza di velocità
detto bit di modalità dove se è 0 siamo in invocata in qualunque punto del
con cui il processore può produrre
kernel mode mentre se è 1 siamo in user programma, il processore viene istruito per
informazioni e quella con cui il dispositivo
mode. andare a eseguire l’intera procedura e poi
può consumarle e distinguiamo tra
ritorna al punto in cui si è verificata la
Quando la cpu esegue un processo utente il operazioni con un dispositivo a blocchi come
chiamata, il suo funzionamento prevede 2
sistema sarà in modalità utente, però il disco e uno a carattere come la stampante
istruzioni di base una di chiamata Call che
quando un applicazione utente richiede un o tastiera.
provoca il salto dalla locazione attuale alla
servizio dal sistema operativo tramite una procedura e l’altra è quella di ritorno ovvero Nel caso di dispositivi a blocchi i dati
chiamata di sistema, il sistema dovrà la Return che rimanda dalla procedura al vengono trasferiti in blocchi di memoria
passare da modalità utente a modalità punto chiamante, entrambe le istruzioni fissa, ad esempio una funzione di lettura
kernel, viceversa una qualunque funzione sono considerate di salto. In pratica quando viene realizzata facendo uso di un buffer di
del SO deve girare con processore in si invoca una procedura l’istruzione Call sistema dove i dati vengono trasferiti dal
modalità kernel cosi da avere il pieno effettua un salto al sottoprogramma disco per poi trasferirli nell’area di memoria
controllo della macchina fisica eseguendo un push automatico del destinataria. Il vantaggio di questa
Questa tecnica di protezione obbliga un contenuto del registro Program Counter organizzazione si ottiene quando il processo
programma applicativo ad accedere alle sullo Stack, al contrario la Return provoca deve leggere ed elaborare non un solo
risorse fisiche esclusivamente per mezzo una pop dalla cima dello Stack al Program blocco di dati ma una sequenza di blocchi in
delle chiamate di sistema, e per ottenere Counter modo tale da rendere parallela
questo bisogna dividere le istruzioni l’elaborazione di un blocco con la lettura nel
Una System Call indica il meccanismo usato
macchina in istruzioni privilegiate e non buffer del blocco successivo, un ulteriore
da un processo a livello utente o livello
privilegiate in modo tale che solo le livello di parallelismo possiamo averlo
applicativo x richiedere un servizio a livello
istruzioni privilegiate possano cambiare lo usando il doppio buffer o con un array
kernel del sistema operativo e le categorie
stato del registro Program Status. Quindi circolare di buffer, un altro vantaggio è
principali di system call sono: controllo dei
solo l’hardware della cpu consente di legato al fatto che il trasferimento di un
processi e thread, gestione dei file e dei file
eseguire istruzioni privilegiate solo in numero di byte può essere inferiore a quella
system, gestione dei dispositivi, gestione
modalità kernel, invece se si tenta di del blocco dati.
delle informazioni e comunicazioni
eseguire un istruzione privilegiata in Nel caso di dispositivi a carattere i dati
modalità utente tale istruzione verrà La system call è una chiamata a una
vengono trasferiti come stringhe di bytes e
considerata illegale e genererà un eccezione subroutine incorporata nel sistema mentre
questo permette di gestire in maniera
che verrà gestita dal SO una chiamata di funzione è una chiamata a
automatica nel buffer di sistema la
una subroutine all’interno del programma. A
Bisogna precisare che le chiamate di sistema cancellazione di caratteri letti da tastiera che
differenza delle chiamate di funzione le
non possono essere delle semplici chiamate successivamente vengono cancellati in
system call vengono usate quando un
di procedura altrimenti la funzione del SO maniera trasparente anche x il processo
programma deve eseguire alcune attività
chiamata verrebbe eseguita con lo stesso applicativo
per le quali non dispone di privilegi, le
valore del registro Program Status con cui system call sono dei punti di ingresso nel
stava eseguendo il programma chiamante in kernel del SO e non sono collegate al
modalità utente. Viene invece usato il programma come invece le chiamate di
meccanismo delle interruzioni in quanto funzione. Le chiamate di funzione sono
permette di eseguire la funzione chiamata portabili e l’overhead di una system call è
con un valore del registro Program Status maggiore rispetto a quella di una chiamata
corrispondente allo stato privilegiato. di funzione in quanto deve avvenire una
File System Per accedere a un file in memoria ci sono ACL Access Control List
Il file system è quella parte del SO che ci essenzialmente 3 metodi: Con una lista di controllo degli accessi (ACL
fornisce i meccanismi x accedere ed Access Control List) suddividiamo la matrice
Accesso sequenziale: dove ogni file è per colonne associando ad ogni oggetto una
archiviare le informazioni in memoria di
organizzato come una sequenza di record lista che contiene tutti i soggetti che
massa, il file system può essere
logici che possono essere letti e scritti possono accedere all’oggetto, e, per ognuno
rappresentato su + livelli ed in particolare:
esattamente nell’ordine prefissato, quindi in di essi, i diritti di accesso specifici. Per ogni
Struttura logica: viene presentata all’utente ogni sessione di accesso al file esiste un oggetto abbiamo l’insieme delle coppie
una visione astratta del contenuto del disco, puntatore che collega l’elemento successivo, <soggetto, insieme dei diritti> Quando un
in pratica l’utente vede file e cartelle, dove abbiamo quindi delle readnext per leggere soggetto tenta di esercitare un diritto di
possiamo accedervi per visionare, l’elemento successivo e writenext per accesso sul un oggetto, il meccanismo di
modificare ed aggiungere delle informazioni, scrivere il prossimo record protezione verifica preventivamente in una
lista di default contenente i diritti di accesso
non conoscendone cmq le tecniche di Accesso Diretto: dove x leggere o scrivere in
generali e successivamente nella ACL
allocazione in memoria utilizzate dal sistema un determinato record non siamo costretti a
associata al dato oggetto se esistesse una
Accesso: definisce i meccanismi x operare scorrere tutti suoi predecessori, questo
coppia il cui primo elemento sia il soggetto
sui file, ogni file è individuato come un metodo è di grande utilità per grosse richiedente ed il secondo elemento sia lo
record logico che è caratterizzato da dimensioni di dati come nel caso dei specifico diritto d’accesso. Se in entrambi i
proprietà come la dimensione e tipo che database casi la risposta fosse negativa l'accesso
possono essere diverse a seconda del SO Accesso ad Indice: dove ogni record prevede all'oggetto verrebbe ovviamente negato. In
usato, in questo livello vengono messe a almeno 2 campi di cui uno è chiamato ACL risulta semplice revocare i diritti di
disposizione dei processi delle system call x chiave, ad ogni file viene quindi associata accesso per un oggetto, in quanto si può far
lavorare su file e in ottica di protezione una tabella ad indice che permette delle riferimento direttamente alla ACL associata
bisogna prevedere degli accessi limitati e/o associazioni dirette tramite la chiave all'oggetto e dunque cancellare ciò che si
personalizzati a seconda dell’utente che è vuole revocare. Risultano complesse, invece,
Per quanto riguarda gli elementi logici
connesso al SO operazioni quali determinare i diritti di
nell’ambito del file system abbiamo 3
Organizzazione Fisica: in questo livello accesso di un soggetto per un particolare
metodologie principali di allocazione
vengono realizzati i metodi di allocazione oggetto in quanto occorrerà esaminare il
fisica dei file sui dispositivi di Allocazione Contigua: dove ogni file occupa contenuto dell’intera ACL associata
memorizzazione blocchi di memoria contigua tra loro, in all'oggetto e verificare se nella lista è
Dispositivo Virtuale: questo livello è questo caso vengono usate le tecniche di presente il soggetto in questione.
essenzialmente a disposizione del allocazione best fit, first fit e worst fit. Lo
precedente in quando lavora direttamente svantaggio è la creazione di frammentazione
sull’hardware organizzando la memoria in Allocazione a Lista Concatenata: dove i file
blocchi di + facile gestione da parte del vengono memorizzati in blocchi non
livello di organizzazione fisica necessariamente contigui tra loro ma
organizzati in una lista concatenata, con
Un file è essenzialmente l’unità logica di
questa metodologia viene eliminata la
memorizzazione all’interno di un file system
frammentazione ma si rischiano
la quale viene individuato tramite un nome
malfunzionamenti nel caso si dovesse
e può inoltre essere di varie tipologie ad
perdere il collegamento tra puntatore di un
esempio testo, immagine, video ed inoltre
blocco e l’altro e per risolvere questo
presenta delle specifiche caratteristiche
problema spesso si ricorrono a liste
come dimensione, data e ora di creazione
doppiamente puntate ed a tabelle di
e/o modifica e nei sistemi multi utente è
allocazione dei file
previsto anche l’indicazione del proprietario
Allocazione a Indice: anche in questo caso
e i diritti di accesso, l’insieme di queste
l’allocazione dei blocchi non è contigua, ad
caratteristiche rientrano nel descrittore del
ogni file viene associato un blocco ad indice
file.
che contiene gli indirizzi dei blocchi
Le directory in via astratta sono contenitori effettivamente utilizzati x l’allocazione.
di più file che insieme a questi ultimi danno Anche con questo metodo si risolve il
vita ad una rappresentazione ad albero, problema della frammentazione ma si
creando cosi delle vere e proprie gerarchie introduce quello della dimensione del
di file e cartelle fino a quella che viene blocco, in questo caso bisognerà
chiamata directory radice cioè la base dimensionare il file alle dimensioni del
dell’albero. Le directory mediante il blocco indici con conseguenti svantaggi e
descrittore del file mantengono un diretto limiti ed alcuni SO come unix x ovviare a
rapporto con i file e solitamente nei SO questo problema hanno introdotto blocchi a
vengono realizzate strutture tabellari x indice su più livelli dove si effettuerà
gestire directory e file che si trovano in esse. l’accesso a un livello dove verranno trovati
gli indirizzi di collegamento degli altri