RIASSUNTO S.O.

RIASSUNTO S.O.

RIPASSO/LETTURA lacune/dubbi
  • Qual è il problema principale dell’approccio Sleep and Wait e come può essere risolto?
  • memory mapped file: link
  • FILE SYSTEM OPTIMIZATION: qui
  • Virtualizzazione: qui
  • Buffer per l’I/O (cosa risolvono e come vanno gestiti): link
  • algoritmo di Dikjstra
  • LVM
  • DIFFERENZA TRA DEVICE DRIVER E DECIVE CONTROLLER: link
COME VIENE GESTITO UN INTERRUPT → (interrupt vector, ISR, assembly)
La multiprogrammazione avviene attraverso interrupt di clock
Un interrupt è un segnale che interrompe il normale flusso di esecuzione della CPU per richiedere attenzione immediata ad un altro processo
Quando arriva un interrupt di clock
CPU → PC e alcuni registri nello stack (salvataggio parziale)
salva lo stato corrente del processo in esecuzione all’interno dello stack relativo, il PCB ha le info utili al recupero di questi dati
CPU → trova l’ISR
  1. accede all’ interrupt vector (una tabella che contiene gli indirizzi delle ISR corrispondenti ai vari tipi di interrupt)
  1. aggiorna il Program Counter (PC) per puntare all'inizio della Interrupt Service Routine (ISR) corrispondente
    1. ISR = codice in C che viene eseguito per gestire un interrupt
esecuzione procedura assembly → salva ulteriori registri (salvataggio totale) e prepara un nuovo stack
  • new stack: per eseguire il codice che gestirà l'interrupt
  • per garantire che la routine di gestione dell'interrupt non sovrascriva lo stack del processo corrente
CPU → esegue l’ISR
  • la CPU esegue l’ISR
  • nel caso del clock, l’ISR segnala al sistema operativo che il time slice del processo corrente è terminato e attiva lo scheduler
scheduler → decide il prossimo processo da eseguire
in base a:
  • priorità
  • stato esecutivo
  • altre info nel PCB
esecuzione procedura in assembly (dispatcher?) → prepara prossimo processo
  • copia i valori salvati nei registri del processo scelto dallo scheduler e il program counter) per eseguirlo da dove era stato interrotto

NOTA

separazione delle Responsabilità:
  • Routine in C: per gestire logiche di alto livello, come l'input/output o la gestione di dati → ISR
  • Codice Assembly: compiti più vicini all'hardware, come la gestione dei registri e il controllo delle istruzioni di basso livello.
  • Il linguaggio assembly è la ragione per cui un sistema operativo non funziona con qualsiasi processore, infatti non è un linguaggio universale ma dipende dall'architettura del processore
SYSTEM CALLS
Come Avviene una System Call
PREPARAZIONE
  1. Il processo utente richiede un'operazione privilegiata, ad esempio la lettura di un file.
    1. nn confondere con l’interrupt → il processo nn è che si arresta improvvisamente
  1. Viene preparata la chiamata alla system call, inserendo i parametri necessari nello stack (non uno nuovo)
    1. il file descriptor
    2. buffer di destinazione
    3. numero di byte da leggere
  1. Il programma utente fa un jump verso un indirizzo in cui trova ed esegue una funzione di libreria standard (stub) che funge da interfaccia tra il programma utente e il kernel.
    1. Lo stub recupera i parametri dallo stack e li memorizza nei registri del processore insieme al numero identificativo della system call (nn viene caricato temporaneamente nello stack)
TRAP
  • Lo stub esegue una speciale istruzione trap, che invia un segnale hardware alla CPU
      • CONSEGUENZE
      1. la CPU cambia modalità, passando dalla modalità utente alla modalità kernel, e avvia l'esecuzione del codice del kernel.
      1. il kernel avviato utilizza una sua componente (dispatch) per trovare nella System Call Table, l'handler associato alla system call in base al numero identificativo della system call
          2. handler
          Ogni system call ha un handler dedicato, che contiene il codice necessario per eseguire l'operazione richiesta
          • esempio di legame tra system call e handler
      1. L'handler della system call esegue l'operazione richiesta, ad esempio la lettura del file, accedendo alle risorse protette.
RITORNO
  1. Una volta completata l'operazione, la CPU ritorna alla modalità utente.
  1. Il programma utente riprende l'esecuzione immediatamente dopo la chiamata alla system call utilizzando i dati caricati nel buffer di destinazione
  • Se la system call non può essere completata immediatamente, il processo viene bloccato. Il sistema operativo può quindi eseguire un altro processo finché non diventa possibile completare la chiamata read.
le system call si suddividono in 4 famiglie:
Gestione dei processi
Funzione della system call fork
  • unico metodo per creare un nuovo processo, genera una copia esatta del processo originale
  • Le variabili condividono gli stessi valori al momento della creazione, ma le modifiche successive non si propagano tra i processi. ù
  • Il codice eseguibile del programma, che è immutabile, viene condiviso tra genitore e figlio.
Restituisce due valori diversi
  • Nel processo figlio: La chiamata a fork() restituisce 0. Questo serve al codice per identificare che si sta eseguendo il processo figlio.
  • Nel processo genitore: La chiamata a fork() restituisce il PID del figlio appena creato. Questo serve al genitore per distinguere il figlio tra altri eventuali figli.
  • PID: numero intero univoco assegnato dal sistema operativo a ogni processo in esecuzione
Pk viene chiamata la fork
  • Quando un comando viene digitato dall’utente, la shell crea un processo figlio che esegue il comando richiesto al posto del processo padre
  • Questo garantisce che qualsiasi errore o crash nel processo figlio non influenzi il processo padre, impedendo la perdita irreversibile del processo
Attesa
  • Il processo genitore attende che il figlio termini l’esecuzione prima di procedere. Questa attesa viene realizzata tramite la system call waitpid.
    • La waitpid permette al genitore di attendere un processo figlio specifico oppure un qualsiasi processo figlio (impostando il primo parametro a -1).
    • Quando waitpid termina, il secondo parametro contiene lo stato di uscita del processo figlio che consente al processo genitore di sapere come è terminato il figlio e se ci sono stati errori.
Esecuzione dei Comandi
  • Dopo che il processo figlio è stato creato, il figlio usa la system call execve per sostituire il proprio codice con il codice del programma da eseguire (ad esempio il programma cp).
  • execve carica eventuali argomenti e variabili d'ambiente necessari al programma.
      • Ad esempio, un comando come cp file1 file2 funziona così:
      1. La shell usa fork per creare un processo figlio.
      1. Il figlio localizza ed esegue il file cp, passando come argomenti file1 e file2.
Parametri della Funzione main
Il programma eseguito da execve inizia con la funzione main, che accetta tre parametri:
  • argc: il numero di elementi nella linea di comando, incluso il nome del programma (ad esempio, per cp file1 file2, argc è 3).
  • argv: un array di stringhe che rappresentano gli argomenti della linea di comando. In questo esempio:
    • argv[0] → "cp"
    • argv[1] → "file1"
    • argv[2] → "file2"
  • envp: un array di stringhe che contiene variabili d'ambiente, utilizzate per personalizzare il comportamento del programma.
      • Nel caso cp, nessun ambiente viene passato al processo figlio, quindi il terzo parametro di execve è 0.
System Call exit
La system call exit viene utilizzata per terminare un processo. Essa accetta un parametro (lo stato di uscita), che può essere un valore compreso tra 0 e 255.
Questo valore viene restituito al processo genitore tramite la waitpid.
Struttura della Memoria dei Processi in UNIX
In UNIX, la memoria di un processo è suddivisa in tre segmenti:
  1. Segmento di testo: contiene il codice eseguibile del processo
  1. Segmento dati (heap): contiene variabili del programma e cresce verso indirizzi di memoria più alti
  1. Segmento stack: contiene le chiamate di funzione e le variabili locali. Cresce verso indirizzi di memoria più bassi
Tra il segmento dati e segmento stack c’è uno spazio vuoto.
  • L'espansione del segmento stack è automatica
  • quella del segmento dati richiede una system call (brk)
Gestione dei file

Apertura di un File

Per leggere o scrivere un file, questo deve essere aperto utilizzando una system call.
Durante l'apertura, è necessario specificare:
  • Nome del file: può essere un percorso assoluto o relativo alla directory corrente.
  • Modalità di apertura:
    • O_RDONLY: solo lettura.
    • O_WRONLY: solo scrittura.
    • O_RDWR: lettura e scrittura.
    • O_CREAT: crea il file se non esiste.
💡
La system call restituisce un file descriptor: un identificatore numerico che viene utilizzato per effettuare letture e scritture sul file. Dopo aver terminato l'operazione, il file può essere chiuso usando close(), rendendo il file descriptor disponibile per altri file.

Lettura e Scrittura dei File

Le system call più utilizzate per lavorare con i file aperti sono:
  • read(): legge dati dal file.
  • write(): scrive dati sul file.
Entrambe richiedono il file descriptor e i buffer per leggere o scrivere i dati.

Accesso Casuale con lseek

La system call lseek() permette di spostare il puntatore del file in una posizione specifica. Ha tre parametri:
  • File descriptor: il file su cui operare.
  • Offset: il numero di byte a cui spostare il puntatore.
  • Modalità di riferimento: specifica se la posizione è
    • All'inizio del file.
    • Alla posizione attuale.
    • Alla fine del file.
      • indicano da quale punto calcolare la nuova posizione del puntatore.
      La posizione finale (valore di ritrno della system call) dipende dal valore dell'offset che aggiungi (o sottrai) rispetto al riferimento scelto.
Gestione delle directory e del file system

Creazione e Rimozione di Directory

  • mkdir(path): Crea una nuova directory vuota specificando il percorso path.
  • rmdir(path): Rimuove una directory vuota, purché non contenga file o sottodirectory.

Creazione di Collegamenti con link

Quando usi ln nel terminale, il sistema operativo esegue la system call link(), creando un hard link.
Quando chiami la system call link(oldpath, newpath), il sistema operativo crea un nuovo file al percorso newpath, ma non crea un nuovo file fisico sul disco, pk il nuovo file condivide lo stesso inode del file originale oldpath
Spiegazione di come avviene
  1. il sistema operativo rintraccia il file originale per mezzo di oldpath e ne ricava l’i-node dalla directory associata (che ha una tabella con le coppie (i-number, nome del file) per ogni file)
  1. con newpath aggiorna tabella della directory da cui parte il collegamento
      • L'i-number èn indicatore della posizione dell'inode all'interno del file system.
  1. Aggiornamento dell'Inode
      • L'inode del file ha un contatore dei riferimenti che viene incrementato di 1. Tiene traccia di quanti file puntano all'inode.

Montaggio dei File System con mount

La system call mount(device, mount_point, flags) permette di unire più file system in uno solo, integrando dispositivi esterni (come USB o CD-ROM) nella gerarchia principale.
Esempio
mount("/dev/sdb0", "/mnt", 0);
  • Primo parametro (device): file system (dispositivo) da montare
  • Secondo parametro (mount_point): La directory in cui sarà montato il file system (es. /mnt).
  • Terzo parametro (flags): Indica se il file system deve essere montato in modalità sola lettura o lettura-scrittura.

Accesso ai File Montati:

Dopo la chiamata mount(), i file sul dispositivo esterno possono essere acceduti normalmente utilizzando il loro percorso a partire dalla root /, senza bisogno di specificare il dispositivo fisico.
  • Smontaggio del File System con umount
  • Gestione di operazioni di tipo variegato
Accensione computer
Quando un computer si accende, la CPU esegue una serie di passaggi per avviare il sistema operativo
  • Premi il pulsante di accensione: fornisce energia ai componenti hardware del PC, quindi avvia la CPU e la scheda madre
  • la CPU esegue il BIOS nella scheda madre
    • il BIOS è un software nella scheda madre di un computer
    • La scheda madre (in inglese, motherboard o mainboard) è il componente principale di un computer, su cui si collegano e comunicano tutti gli altri componenti hardware.
cosa fa il BIOS?
  • Il BIOS/UEFI individua il disco fisso e carica in memoria, un settore del disco chiamata Master Boot Record (MBR) o settore 0, il cui codice è chiamato bootloader primario
cosa fa il bootloader primario?
  1. esamina al suo interno la tabella delle partizioni per trovare ed eseguire la partizione contrassegnata come partizione attiva (flag), ossia quella designata per l'avvio del sistema operativo, pk il primo settore(boot sector) di quella partizione contiene il bootloader secondario
      • I file system sono archiviati su dischi
      • i dischi possono essere suddivisi in una o più partizioni (sezioni logiche), ciascuna con un proprio file system indipendente
        • ogni partizione si compone di blocchi fisici chiamati settori
          • nei sistemi Linux in specifico: ogni partizione ha come primo settore il boot block, nel caso più specifico della partizione designata per l'avvio del sistema operativo (flag), questo si chiama boot sector
  1. quindi carica in memoria il boot sector
      • il cui codice è chiamato bootloader secondario
cosa fa il bootloader secondario?
  • carica in memoria il kernel
cosa fa il kernel?
  • Il kernel prende il controllo del sistema.
  • Inizia l'inizializzazione dei componenti hardware e delle risorse di sistema, il primo processo del kernel è chiamato Init
  • primo processo: qui
DIMENSIONE OTTIMALE DELLA PAGINE

Introduzione al Problema

La gestione della memoria richiede di determinare una dimensione ottimale per le pagine al fine di bilanciare l'uso della memoria e minimizzare gli sprechi. Non esiste una dimensione ideale valida in tutti i casi, quindi si utilizza un approccio statistico per stimare i costi e benefici di diverse dimensioni.
  • in verità si era stabilito che con la page table a più livelli o invertita le pagine potessero essere anche piccolissime
  • obiettivo = calcolare overhead di un processo = dimensione media frammentazione interna e numero di entry del processo in tabella per definire il giusto compromesso
notion image
notion image
notion image
notion image
notion image
MPEG (processo di compressione)
  1. Separazione dei colori in formato YUV
      • I colori dell'immagine vengono rappresentati nel formato YUV: la componente di luminanza (Y) e due componenti di crominanza (U e V). Questo formato è più efficiente rispetto al classico RGB, poiché sfrutta il fatto che il nostro sistema visivo è più sensibile alla luminanza rispetto al colore.
  1. Divisione dell'immagine in blocchi 8x8 pixel
      • per analizzare e comprimere le informazioni localmente
      • matrici 8x8 che rappresentano l'intensità o il colore di quei pixel
  1. Trasformata a coseno discreta (DCT) → (trasformazione)
      • Viene applicato un filtro matematico (DCT) a ciascun blocco per convertire le informazioni spaziali in frequenze. Questo permette di distinguere i blocchi con informazioni importanti da quelle meno rilevanti
  1. Linearizzazione della matrice → (array)
      • La matrice risultante dalla DCT (8x8) viene trasformata in un array, con i valori più significativi (calcolati dal DCT e posizionati in alto a sinistra) e quelli meno importanti (vicini allo zero) rappresentati in sequenza.
  1. Compressione dei valori
      • I valori vicino a zero possono essere eliminati o compressi molto efficacemente, riducendo notevolmente lo spazio occupato.
"priority inversion"
  • la priority inversion nel contesto descritto può verificarsi con algoritmi come Peterson's algorithm, o altri algoritmi di sincronizzazione che utilizzano busy waiting
      • SCENARIO DESCRITTO
  • Supponiamo di avere due processi:
    • H: un processo con alta priorità.
    • L: un processo con bassa priorità.
  • Se il processo L entra nella regione critica e il processo H vuole accedervi:
    • H inizia il busy waiting per accedere alla regione critica.
    • Poiché H ha priorità più alta, il sistema di scheduling gli assegna costantemente la CPU.
    • Il processo L, avendo priorità bassa, non viene mai schedulato per uscire dalla regione critica.
    • Risultato: H è bloccato in un ciclo infinito, e il sistema è in uno stato di deadlock implicito.
      • SOLUZIONE
  • Sleep sospende il processo in attesa (ad esempio, H) finché non è svegliato.
    • quindi nn rientra più tra le opzioni dello scheduler
      •  
SCENARIO PRODUTTORE-CONSUMATORE
  • Scenario di Producer-Consumer:
    • Due thread collaborano in un tipico schema producer-consumer:
      • Producer: Riempie un buffer condiviso (lavoro più pesante, quindi ha una priorità alta, es. 12).
      • Consumer: Svuota il buffer condiviso (lavoro meno intensivo, priorità bassa, es. 4).
  • Il problema:
    • Il producer lavora finché il buffer è pieno, poi si blocca su un semaforo, aspettando che il consumer svuoti il buffer.
    • Mentre il consumer è in attesa di essere eseguito, un altro thread non correlato con priorità intermedia (es. 8) diventa pronto per l'esecuzione e prende la CPU.
  • Situazione di Priority Inversion:
    • Il thread con priorità 8 continua a essere schedulato, impedendo al consumer (priorità 4) di essere eseguito.
    • Poiché il producer (priorità 12) dipende dal lavoro del consumer per progredire, anche il producer rimane bloccato.
    • Il risultato è che un thread a priorità più bassa (consumer) non può essere eseguito per liberare la risorsa richiesta da un thread a priorità più alta (producer), a causa di un thread a priorità intermedia (thread 8) che monopolizza la CPU.
  • la TSL è un istruzione
  • Le page fault si verificano solo quando un indirizzo non è presente in memoria fisica, e ciò viene rilevato consultando la tabella delle pagine
Problema produttore e consumatore con sleep and wake up
SINTESI: si verifica inconsistenza nella fase tra test e set e nella fase tra test e systemCall, quest’ultimo può causare deadlock, pk il processo può fare il test, essere interrotto, eseguire la sleep in seguito quando però la variabile full nn è più pari a N, quindi nn fa più wakeup pk è andato in sleep nel momento sbagliato → deadlock
In presenza del buffer pieno un produttore si mette in sleep, ma se lo scheduler toglie la CPU dopo aver controllato l'if ma prima di andare in sleep e un consumatore toglie un'informazione dal buffer e invia un wakeup, il processo di prima non è entrato in sleep quindi appena toccherà di nuovo a lui andrà in sleep con count = buffer_max_size-1 o meno. La prossima volta che il consumatore toglierà un elemento, count sarà uguale a buffer_max_size-n-1, buffer_max_size-n-2, ecc, e la wakeup non viene più mandata (viene mandata quando il buffer è a max_buffer_size-1) → il sistema va in deadlock
Quanti semafori ha bisogno il problema del produttore consumatore?
Tre: un mutex per gestire mutua esclusione, un semaforo per gli elementi occupati e uno per gli elementi vuoti all’interno del buffer (array). A quanto sono inizializzati? Mutex a 1, semaforo vuoti = N, semaforo pieni = 0
Scheduling con priorità: i processi sono trattati diversamente in base alla loro priorità
  • Priorità statica: assegnata alla creazione di un processo, non può essere cambiata (vengono schedulati prima i processi I/O bound)
  • Priorità dinamica: cambia a seconda di certe statistiche, può cambiare anche mentre il processo non è in esecuzione.
  • Vantaggi e svantaggi dei diversi algoritmi di gestione delle risorse condivise: QUI
  • FAT
DIFFERENZA DISPATCHER E SCHEDULER
  • Il dispatcher è il modulo responsabile di effettuare concretamente il cambio di contesto, ovvero di passare l'esecuzione dal processo attuale a quello scelto dallo scheduler.
  • Lo scheduler è il componente del sistema operativo che decide quale processo deve essere eseguito dalla CPU in base a determinate politiche di scheduling.
ALGORITMI
SINTESI STEP DOPO STEP ALLOCAZIONE PAGINA
Richiesta della CPU
  • La CPU richiede un processo consegnando alla MMU l’indirizzo virtuale
    • non sa se la pagina è caricata in RAM o nel file swap. Quindi necessita di traduzione MMU
Divisione dell'Indirizzo Virtuale
  • La MMU divide l'indirizzo virtuale in Numero di Pagina Virtuale (ID) e Offset.
  • TLM miss(prima fase di rallentamento = accesso alla tabella in RAM) / hit
Accesso alla Page Table
  • Verifica il flag di presenza per determinare se la pagina è in RAM.
    • La MMU usa l'ID per accedere alla voce corrispondente nella Page Table, l’ID è riferito all’intera pagina.
    • La Page Table mappa intere pagine virtuali a frame fisici (ci sono diverse implementazioni, tutte fanno uso dell’ID)
  • Ottiene l'identificativo del frame fisico dalla Page Table
    • Ogni frame ha un identificativo univoco (numero di frame) che indica la sua posizione all'interno della RAM
FLAG = 1 → la Pagina è in RAM (SOFT Miss)
  • Calcola l'indirizzo fisico combinando l'identificativo del frame con l'offset.
    • offset per trovare l’istruzione di partenza all’interno del frame
  • La CPU accede alla specifica istruzione del processo (da cui partirà l’esecuzione) in RAM utilizzando l'indirizzo fisico.
FLAG = 0 → la Pagina non è in RAM (HARD Miss) **🐌🐌
  • il flag di presenza in tal caso da valore 0, indicando che la pagina NON è attualmente in RAM → si genera una trap di page fault → seconda fase di rallentamento = swap-out(+page out) e page-i
      1. il processo passa in stato di blocked, per effettuare il caricamento
      1. SWAP-OUT(se necessario): È l'operazione di spostamento dell'intero processo (o di una sua parte) dalla RAM al disco per liberare memoria fisica.
        1. scelta di una vittima: qui gli algoritmi
        2. PAGE OUT: operazione I/O di scrittura su disco di una pagina modificata che deve essere rimossa dalla RAM → solo se ci sono modifiche
      1. SWAP-IN È l'operazione di ricaricamento di un processo (o di una sua parte) dalla memoria di swap (disco) alla RAM per riprendere l'esecuzione.
          • PAGE-IN: operazione I/O di lettura dal disco per caricare in RAM una pagina richiesta che non è attualmente presente → avviene sempre per eseguire swap-in
      1. La Page Table viene aggiornata per riflettere la nuova posizione della pagina, e la TLB può essere aggiornata per accelerare gli accessi futuri a quell’indirizzo.
      1. ROLLBACK + READY:
        1. Il sistema operativo effettua un ROLLBACK dell'istruzione che ha causato il page fault, ripristinando il contatore del programma (PC) in modo che l'istruzione venga rieseguita dall'inizio. (Sta volta con il pezzo di codice in RAM)
        2. il processo viene rimesso nello stato di "ready” pk il page fault ha esaurito il suo quanto di tempo
            • Quindi la MMU ripete la traduzione dell'indirizzo virtuale (pk lo scopo era individuare la posizione in RAM ma nn era nemmeno in RAM se c’è hard miss)
CHIAREZZA
  • Se necessario si fa swap-out e page-out, poi si fa necessariamente swap-in e quinci page.in
 
ALTRI DETTAGLI
  • Memoria virtuale e memoria fisica non sono necessariamente di uguale dimensione.
    • però se il byte che mi interessa è in posizione 80 nella pagina, allora è in posizione 80 anche nel frame finchè entrambi condividono lo stesso valore di indirizzo.
  • La page table non contiene unicamente l’ID, il flag e l’identificatore del frame, non al giorno d’oggi. Altri elementi sono:
    • bit di protezione: posso associargli dei livelli di protezione. Ad esempio, si può solo scrivere, o solo leggere, o scrivere
      e leggere.
        • Tipi di Permessi(già affrontati)
        • Read (R): Permette la lettura dei dati dalla pagina.
        • Write (W): Permette la scrittura o modifica dei dati nella pagina.
        • Execute (X): Permette l'esecuzione di istruzioni contenute nella pagina.
        • Combinazioni: Le pagine possono avere combinazioni di questi permessi (es. solo lettura, lettura e scrittura, ecc.).
    • Il bit di modifica: indica se il contenuto di una pagina è stato modificato da quando la pagina è stata caricata in RAM, in caso affermativo salva una copia aggiornata anche nel disco (memoria virtuale)
    • Il bit di riferimento: indica se una pagina è stata acceduta (letta o scritta) di recente. Implementazione del principio di località, in quanto aiuta il sistema operativo a tenere traccia delle pagine più utilizzate per ottimizzare la gestione della memoria.
ALGORITMI DI ALLLOCAZIONE DINAMICA (DEI PROCESSI)
FITRST FIT
NEXT FIT
BEST FIT
WORST FIT
QUICK FIT
ALGORITMI DI SCHEDULING (POLITICHE DI CHEDULING)
FCFS
SJF
SRTF (PRELAZIONE AD OGNI ISTANTE)
 
(PRELAZIONE CON QUANTO DI TEMPO)
ROUND ROIBIN
SCHEDULING CON PRIORITA’
 
GUARANTEED SCHEDULING
LOTTERY
FAIR SHARING
EDF / RMS
THREAD SCHEDULING
 
ALGORITMI SCELTA VITTIMA
  • ALGORITMO OTTIMO (Page Mark)
  • FIFO
  • SECONDA CHANCE
  • OROLOGIO
  • LRU
  • NRU
      • NFU
      L’algoritmo NFU (Not Frequently Used) inserisce nella logica dell’LRU il concetto di aging (invecchiamento).
      Quello che fa è cercare di assegnare un ordine alle pagine che sia semplice da conservare:
      1. associa un’etichetta numerica ad ogni pagina
      1. ad ogni clock il valore numerico viene shiftato a destra ➡️ introducendo il bit di referenza come bit più significativo. Pertanto procedendo nel tempo mi troverò con i valori più alti associati alle pagine che hanno i bit più significativi 1. A lungo andare si creano delle etichette che definiscono 256 categorie.
      1. Quando c’è un page fault viene rimpiazzata la pagina con l’etichetta col valore più basso, che sarà quella acceduta meno frequentemente.
  • ALGORITMI BASATI SU WORKING SET
ALGORITMI PREVENIRE LA RACE CONDITION
  • DISABILITO GLI INTERRUPT
  • VARIABILI DI LOCK
      • - - - - -
  • TSL
  • ALTERNANZA STRETTA
  • ALGORITMO DI PEATERSON
      • - - - - -
  • SLEEP AND WAIT (consumatore/produttore)
LISTA TRAP
  • trap di segmentation fault(processore): link
    • trap di interruzione software (arresta il processo quando stack segment e heap segment collidono)
  • trap di passaggio CPU a kernel mode (STUB)
  • trap di page fault (lanciata dalla MMU)
LISTA INTERRUPT
  • interrupt di clock
  • interrupt di fine esecuzione operazione I/O
LISTA STRUTTURE
  • Struttura memoria processo: qui
  • Layout Partizione: qui
    • I-NODE:
      • struttura: qui
      • applicazione: qui
SOLA LETTURA
  • Le pagine da swap a ram non vengono copiate bensì trasferite, anche se i libri usano il termine copiare
  • Multiprogrammazione -> inserisco gruppi di job (sistema batch multiprogrammato)
  • Thread → condividono info pk tramite Zona di codice condivise
  • MAPPATURA DATA BLOCK/PAGINE hanno una struttura uguale ma nomi differenti
    • PAGE TABLE A PIU’ LIVELLI
    • I-NODE CON PUNTATORI CHE DIREZIONANO BLOCCHI CONTENENENTI ALTRI PUNTATORI