Scarica CPU Scheduling: Algoritmi e Ottimizzazione nei Sistemi Operativi - Prof. Spalazzi e più Appunti in PDF di Sistemi Operativi solo su Docsity!
Scheduling (unità 3)
L'obiettivo dello scheduling è decidere quale processo, tra quelli pronti, deve ottenere l'accesso alla CPU e per quanto tempo. L’esecuzione di un processo non è un'attività continua, ma un' alternanza di due fasi :
- CPU Burst (Ciclo di CPU): Un periodo in cui il processo esegue calcoli, elabora dati e usa intensamente la CPU.
- I/O Burst (Ciclo di I/O): Un periodo in cui il processo è bloccato in attesa che un'operazione di Input/Output (I/O) termini. Esempi: attendere la lettura di dati da un disco, aspettare un input dalla tastiera, attendere una risposta dalla rete. Durante un I/O Burst, il processo non può usare la CPU , anche se questa fosse libera. Questo "tempo morto" è la ragione principale per cui esistono i sistemi operativi multitasking e lo scheduling: mentre un processo aspetta l'I/O, la CPU può essere assegnata a un altro processo, massimizzando l'efficienza del sistema. Sapendo che i processi si alternano tra l'uso della CPU e l'attesa, il sistema operativo ha bisogno di un modo per tenerli organizzati. Lo fa usando diverse code. Ogni elemento in queste code non è il processo stesso, ma il suo PCB (Process Control Block) , che è la "carta d'identità" del processo contenente tutte le sue informazioni Ready Queue (Coda dei pronti): È la coda più importante per lo scheduler. Contiene tutti i processi che sono pronti per essere eseguiti e stanno solo aspettando che la CPU si liberi. Lo scheduler sceglie da questa coda. I/O Queues (Code di I/O): Non ne esiste solo una. C'è una coda separata per ogni dispositivo di I/O (disco, nastro magnetico, terminale, etc.). Queste code contengono i processi che sono bloccati in attesa che uno specifico dispositivo completi la sua operazione. Job Queue (Coda dei lavori): Questa è la "lista mastro" che contiene tutti i processi presenti nel sistema, in qualsiasi stato si trovino.
Questo diagramma mette insieme tutti i pezzi e mostra il ciclo di vita di un processo all'interno del sistema.
- Un processo viene scelto dalla ready queue (coda dei pronti) e gli viene assegnata la CPU. Ora è nello stato running.
- Un processo lascia la CPU per uno dei seguenti motivi: o Fa una richiesta di I/O (I/O request): Viene spostato nella coda di I/O appropriata (stato waiting ) e attende. Una volta completato l'I/O, torna nella ready queue. o Scade il suo quanto di tempo (time slice expired): Nei sistemi time-sharing, a ogni processo viene dato un piccolo "quanto" di tempo. Se non finisce prima, viene interrotto e rimesso nella ready queue per dare spazio a un altro. o Crea un processo figlio (fork a child): Può dover attendere che il figlio termini, uscendo quindi dallo stato running. o Attende un interrupt (wait for an interrupt): Può mettersi volontariamente in attesa di un evento specifico.
- Quando si verifica un interrupt (un segnale hardware o software), il processo in esecuzione viene messo in pausa, l'interrupt viene gestito, e il controllo torna allo scheduler, che può decidere di riassegnare la CPU. Cosa mostra il grafico: L'asse X è la durata di un CPU burst in millisecondi, l'asse Y è la frequenza (quanti burst di quella durata si verificano). L'interpretazione: C'è un picco altissimo per durate molto brevi e poi la curva scende rapidamente. Questo significa che la stragrande maggioranza dei CPU burst è molto corta. I processi tendono a eseguire pochi calcoli e poi a richiedere subito un'operazione di I/O. I burst di calcolo lunghi e ininterrotti sono molto più rari. Quindi separiamo i processi in:
- Processi I/O-bound : Hanno molti CPU burst cortissimi, alternati a lunghe attese di I/O(es. un editor di testo, un browser web).
Individuiamo Tre tipologie di Scheduler
- Scheduler a Lungo Termine (o Job Scheduler) Questo scheduler è il "buttafuori" all'ingresso del sistema. Cosa fa: Decide quali processi, tra tutti quelli sottomessi dall'utente e in attesa su disco, possono essere ammessi nella memoria principale (nella ready queue ). Frequenza: Viene eseguito molto di rado (ogni svariati secondi o minuti). Proprio per questo, può permettersi di essere più lento e complesso. Obiettivo: Controllare il grado di multiprogrammazione , ovvero il numero totale di processi presenti in memoria. Il suo scopo è trovare un buon mix di processi (es. un po' CPU-bound, un po' I/O-bound) per non sovraccaricare il sistema e mantenere buone prestazioni.
- Scheduler a Medio Termine Questo scheduler è il "gestore del sovraccarico". Non è presente in tutti i sistemi operativi. Cosa fa: Se la memoria è troppo piena o il sistema è sovraccarico, questo scheduler può decidere di "sospendere" temporaneamente un processo. Lo "scarica" dalla memoria e lo salva su disco ( swapping-out ). Successivamente, deciderà quando ricaricarlo in memoria ( swapping-in ) per farlo tornare in competizione per la CPU. Frequenza: Viene eseguito di rado (ogni qualche secondo), quando necessario per gestire il carico del sistema. Obiettivo: Ridurre il grado di multiprogrammazione temporaneamente per migliorare le prestazioni o liberare memoria.
- Scheduler a Breve Termine (o CPU Scheduler) Questo è lo scheduler a cui si pensa più comunemente, l' "addetto alla giostra". Cosa fa: È il più attivo. Decide quale processo, tra tutti quelli nella ready queue (la coda dei pronti), deve ottenere l'accesso alla CPU per il prossimo intervallo di tempo. Frequenza: Viene eseguito molto frequentemente (ogni pochi millisecondi). Per questo, deve essere estremamente veloce , altrimenti il tempo speso a decidere sarebbe maggiore del tempo di esecuzione stesso. Obiettivo: Massimizzare l'utilizzo della CPU e la reattività del sistema, scegliendo il prossimo processo da eseguire in modo efficiente.
JOB SCHEDULER
Il suo compito non è decidere chi usa la CPU adesso, ma chi ha il permesso di entrare nel sistema e competere per le risorse. il Job Scheduler gestisce la transizione di un processo dallo stato new allo stato ready. La sua funzione principale è controllare il grado di multiprogrammazione , ovvero quanti processi sono attivi in memoria contemporaneamente. Prima di ammettere un nuovo processo, si pone una domanda fondamentale: "C'è abbastanza memoria e risorse per un altro processo, o l'aggiunta di questo nuovo processo rallenterà tutti gli altri?". Il termine "trashing" si riferisce a una situazione in cui la memoria è così piena che il sistema passa più tempo a spostare dati tra RAM e disco (swapping) che a eseguire lavoro utile, causando un crollo delle prestazioni. Il Job Scheduler deve evitare questo. Se la risposta è sì e c'è spazio, lo scheduler seleziona uno o più processi dalla "coda dei lavori" (processi su disco in attesa di essere eseguiti). Una volta scelto un processo, il Job Scheduler lo carica in memoria, inserisce il suo descrittore (il PCB - Process Control Block) nella ready queue (coda dei pronti), e ne cambia lo stato da new a ready Da questo momento in poi, il processo è ufficialmente "dentro" il sistema e sarà gestito dallo scheduler a breve termine (CPU scheduler) per ottenere l'accesso alla CPU. Non si occupa di performance istantanee, ma della stabilità e performance complessiva del sistema a lungo termine, mantenendo un mix equilibrato di processi.
nell'area swapped-out processes su disco. Successivamente, lo riprende da lì e lo reinserisce nella ready queue.
CPU SCHEDULER
Lo CPU Scheduler è il componente che decide a chi tocca adesso. il suo compito è selezionare un processo tra tutti quelli presenti nella ready queue (la coda dei pronti in memoria) e decidere di allocargli la CPU. Lo scheduler non è sempre attivo, ma entra in gioco in momenti specifici, quando avviene un cambio di stato di un processo:
- Un processo passa da running a waiting (es. fa una richiesta di I/O).” Il processo che stava usando la CPU fa una richiesta di I/O (es. legge un file). Ora è bloccato e non può più usare la CPU. La CPU è libera! Lo scheduler deve guardare la ready queue e scegliere un nuovo processo da mandare in running.”
- Un processo passa da running a ready (es. scade il suo quanto di tempo, Il processo attuale è stato messo in panchina. L'allenatore deve decidere chi far giocare adesso. Potrebbe scegliere lo stesso processo se ha ancora la priorità più alta, o potrebbe sceglierne un altro).
- Un processo passa da waiting a ready (es. la sua operazione di I/O è terminata). “Un processo che era bloccato in attesa di un I/O ha finito Ora è pronto a usare di nuovo la CPU e viene messo nella ready queue Un nuovo giocatore è tornato disponibile in panchina. L'allenatore deve chiedersi: "Questo giocatore appena tornato è così importante da dover sostituire subito quello che sta giocando adesso?". Se il nuovo processo ha una priorità più alta di quello in running, lo scheduler potrebbe decidere di effettuare un cambio.”
- Un processo termina (exit). “Il processo che stava usando la CPU ha finito tutto il suo lavoro. Come nel caso 1, la CPU è libera. Lo scheduler deve scegliere un nuovo processo dalla ready queue.” La differenza fondamentale tra gli algoritmi di scheduling si basa su quali di questi quattro momenti vengono sfruttati: Scheduling Non-Preemptive (senza diritto di prelazione): o Come funziona: Una volta che la CPU viene assegnata a un processo, nessuno può togliergliela. Il processo la tiene finché non la rilascia volontariamente , o perché termina (caso 4) o perché si mette in attesa per l'I/O (caso 1). o Caratteristica: È un approccio più semplice, ma meno reattivo. Un processo lungo può monopolizzare la CPU. Scheduling Preemptive (con diritto di prelazione):
o Come funziona: Il sistema operativo ha il potere di interrompere un processo e sottrargli la CPU con la forza , anche se questo non ha ancora finito il suo lavoro. o Caratteristica: Questo tipo di scheduling agisce in tutti e quattro i casi. È fondamentale per garantire la reattività e l'interattività dei sistemi moderni (come Windows, macOS, Linux, Android), perché impedisce a un singolo processo di bloccare tutti gli altri.
CPU SCHEDULING NEI SISTEMI MONOPROCESSORE
I cinque principali criteri di performance utilizzati per valutare e confrontare l'efficacia dei diversi algoritmi di scheduling. Un buon scheduler cerca di trovare il miglior equilibrio possibile tra questi indicatori, che spesso sono in conflitto tra loro. Vediamoli uno per uno.
- Utilizzo della CPU (CPU Utilization): Vogliamo che il nostro processore, che è il motore del computer, lavori il più possibile e non stia mai fermo a non fare nulla. Da massimizzare.
- Produttività (Throughput): Il numero di processi che vengono completati in una data unità di tempo. Un throughput elevato significa che il sistema è efficiente e smaltisce molti task. Da massimizzare.
- Tempo di Completamento (Turnaround Time): L'intervallo di tempo totale che intercorre tra il momento in cui un processo viene sottomesso al sistema e il momento in cui termina completamente. Un tempo di completamento basso indica che i singoli processi vengono gestiti rapidamente. Da minimizzare
- Tempo di attesa: La somma di tutti i periodi di tempo che un processo passa nella ready queue, in attesa del suo turno per usare la CPU. È una misura diretta dell'efficienza dello scheduler nel non far aspettare inutilmente i processi pronti. Da minimizzare
- Tempo di risposta: tempo che passa da quando un utente fa una richiesta (es. un clic) a quando il sistema produce la prima risposta visibile, non necessariamente l'output finale. Questo è il criterio più importante per i sistemi interattivi, perché misura la fluidità e la reattività dell'esperienza utente. Da minimizzare. INIZIAMO CON GLI ALGORITMI FCFS: l primo che arriva, viene servito per primo è una politica di scheduling non- preemptive. I processi vengono serviti esattamente nell'ordine in cui arrivano nella ready queue , come persone in fila alla posta. Una volta che un processo ottiene la CPU, la tiene
finché non ha terminato il suo CPU burst. Ma cambiando i processi di arrivo Confrontando i due scenari, il tempo medio di attesa è passato da 17 ms a 3 ms, un miglioramento enorme. Questo evidenzia il difetto principale dell'algoritmo FCFS: l'Effetto Convoglio (Convoy Effect). L'effetto convoglio si verifica quando processi brevi sono costretti ad attendere in coda dietro a un processo molto lungo. Questo degrada notevolmente le prestazioni medie del sistema, in particolare il tempo di attesa medio. SJF: Shortest-Job-First non si basa sull'ordine di arrivo ma sulla durata del lavoro da compiere. L'idea è quella di dare la precedenza ai processi più brevi per "toglierli di mezzo"
Non-Preemptive SJF una volta che un processo ottiene la CPU, la tiene finché non ha completato il suo burst, anche se nel frattempo arriva un processo più breve. Tempo 0: L'unico processo nella ready queue è P1. Parte P1 e, siccome è non- preemptive, continuerà a girare per tutti i suoi 7ms. Tempo 2: Arriva P (burst=4). Va in coda. Tempo 4: Arriva P (burst=1). Va in coda. Tempo 5: Arriva P4 (burst=4). Va in coda. Tempo 7: P1 finisce. Lo scheduler ora guarda la ready queue, che contiene {P2(4), P3(1), P4(4)}. Sceglie il processo con il burst più breve: P3. Parte P3. Tempo 8: P3 finisce. La ready queue ora contiene {P2(4), P4(4)}. I due processi hanno la stessa durata. In caso di parità, si usa la politica FCFS (First-Come, First-Served). Poiché P2 è arrivato prima di P4, parte P. Tempo 12: P2 finisce. L'unico processo rimasto è P4 , che parte. Tempo 16: P4 finisce. Preemptive SJF (o SRTF) Se arriva un nuovo processo il cui burst è più breve del tempo rimanente del processo attualmente in esecuzione, il sistema interrompe (preemption) il processo corrente per far partire quello nuovo e più breve. Tempo 0: Arriva P1 (burst=7). Parte P1. Tempo 2: Arriva P2 (burst=4). Lo scheduler confronta: tempo rimanente di P1: 7 - 2 = 5ms; Burst di P2: 4ms. Poiché 4 < 5, P1 viene interrotto e parte P2. Segnaliamo cosa succede al Tempo 5: P3 finisce (il suo burst era di solo 1ms). Arriva P4 (burst=4). Lo scheduler guarda la ready queue, che ora contiene: {P1(rim. 5), P2(rim. 2), P4(burst 4)}. Il più breve è P2 , che riprende l'esecuzione. E continua così per i successivi tempi.
Tempo di Attesa = (Tempo Totale Trascorso) - (Tempo di Esecuzione Effettivo) - (Tempo di Arrivo) SJF è teoricamente ottimale ma ha un problema pratico insormontabile: come si fa a conoscere in anticipo la durata del prossimo CPU burst di un processo? La risposta è che non si può. Si può solo provare a stimarla (prevederla) basandosi sul comportamento passato del processo. La Media Esponenziale: L'idea è di prevedere il futuro basandosi sul passato, ma dando più peso agli eventi recenti. La prossima previsione (tau_n+1) τ n+1=α ⋅ tn + (1 − α)⋅ τn t_n: La durata reale dell'ultimo CPU burst (il dato misurato). tau_n: La previsione che avevamo fatto per l'ultimo CPU burst. alpha: È un peso (o fattore di smorzamento) compreso tra 0 e 1. Controlla l'importanza che diamo alla storia recente rispetto a quella passata. tau_n+1: La nuova previsione per il prossimo CPU burst. τ₁: Rappresenta la stima della durata del primissimo CPU burst di un processo appena creato. c: È una costante , un valore predefinito scelto dal sistema operativo. Rappresenta la nostra "migliore ipotesi a priori" quando non sappiamo assolutamente nulla del comportamento di un nuovo processo. Se alpha=0: La formula diventa tau_n+1=tau_n. la nostra previsione non cambia mai. Ignoriamo completamente l'ultimo dato reale e ci teniamo la stima iniziale per sempre. La storia del processo non conta nulla. Se alpha=1: La formula diventa tau_n+1=t_n. La nostra prossima previsione sarà semplicemente uguale all'ultima durata effettiva. Ignoriamo tutta la storia passata e ci basiamo solo sull'ultimo comportamento. Questo rende la stima molto reattiva ma anche molto instabile. alpha=0.5: In questo caso, la nuova stima è esattamente la media tra l'ultimo valore reale e l'ultima previsione, dando lo stesso peso alla realtà e alla stima passata. La linea a gradoni (t_i) rappresenta la durata reale dei successivi CPU burst di un processo.
l principale svantaggio di un sistema a priorità rigide è la starvation (attesa indefinita). se continuano ad arrivare processi con priorità alta, i processi con priorità bassa potrebbero non essere mai scelti dallo scheduler. La Soluzione: Aging (Invecchiamento): Per risolvere il problema della starvation, si usa una tecnica chiamata Aging (invecchiamento). È un meccanismo che aumenta dinamicamente la priorità di un processo man mano che questo invecchia, cioè man mano che passa tempo in attesa nella ready queue.
Round Robin L'algoritmo Round Robin è una versione preemptive dell'algoritmo FCFS. L'idea di base è di dare a ogni processo un "piccolo assaggio" della CPU, a turno, in modo equo. Viene definita una piccola unità di tempo, chiamata quanto di tempo o time slice (di solito tra 10 e 100 millisecondi). Ogni processo ottiene la CPU per un periodo di tempo non superiore a un quanto di tempo. Se il processo finisce il suo CPU burst prima che scada il quanto di tempo, rilascia la CPU volontariamente. Se il processo sta ancora girando quando il quanto di tempo scade, un timer genera un interrupt. Il sistema operativo interviene, interrompe (preemption) il processo e lo sposta alla fine della coda dei pronti. La ready queue viene gestita come una semplice coda circolare (FIFO). Il processo scelto è quello in testa alla coda; un processo interrotto viene messo in fondo. uesto meccanismo garantisce che nessun processo possa monopolizzare la CPU. se ci sono n processi nella coda, ogni processo riceverà il suo turno sulla CPU al massimo dopo aver atteso per il tempo di esecuzione degli altri n-1 processi. Le prestazioni dell'algoritmo Round Robin dipendono in modo critico dalla lunghezza del quanto di tempo q. Se q è molto grande: Immagina un q più lungo del più lungo dei CPU burst. In questo caso, nessun processo verrà mai interrotto perché scade il tempo. Ogni processo partirà e finirà il suo lavoro senza essere fermato. L'algoritmo RR diventa a tutti gli effetti un FCFS. Se q è molto piccolo: Un q piccolo migliora il tempo di risposta , perché i processi ottengono la CPU molto frequentemente per brevi periodi, dando all'utente la sensazione che il sistema sia molto reattivo. Ogni volta che un processo viene interrotto e ne parte un altro, c'è un costo operativo, la commutazione di contesto (context switch). Se il quanto di tempo q è troppo piccolo e si avvicina alla durata del context switch (es. q = 10ms, context switch = 5ms), il sistema passerà una parte enorme del suo tempo a fare cambi di contesto invece che lavoro utile.ù
scheduler serve sempre i processi della coda a priorità più alta. Passa a una coda a priorità più bassa solo se tutte le code a priorità superiore sono vuote. Se arriva un nuovo processo nella coda foreground mentre sta girando un processo background, quest'ultimo viene immediatamente interrotto (prelazione). Rischio di starvation.
- Time Slice (Quanto di Tempo tra le Code): Ad ogni coda viene assegnata una porzione del tempo totale della CPU. '80% del tempo della CPU è dedicato a servire la coda foreground (con RR), e il 20% del tempo è dedicato alla coda background (con FCFS). Questa soluzione è più equa e previene la starvation , garantendo che anche i processi a bassa priorità facciano progressi. Multilevel Feedback Queue (Code a Più Livelli con Retroazione). Questo algoritmo migliora il Multilevel Queue standard risolvendo il suo principale difetto: la rigidità. A differenza del Multilevel Queue, dove un processo viene assegnato a una coda e vi rimane per sempre, nel Multilevel Feedback Queue (MFQ) un processo può spostarsi tra le code. Questa mobilità è il "feedback" (retroazione) a cui si riferisce il nome: il sistema operativo osserva il comportamento di un processo e lo sposta nella coda più appropriata in base a quel comportamento. due meccanismi di spostamento:
- Spostamento verso il basso (Demotion) Un processo usa la CPU per periodi molto lunghi, comportandosi da processo CPU- bound. Viene spostato in una coda a priorità più bassa. Separare i processi "pesanti" da quelli "leggeri". In questo modo, i processi interattivi e I/O-bound (che hanno burst di CPU brevi) rimangono nelle code ad alta priorità, garantendo un'ottima reattività al sistema.
- Spostamento verso l'alto (Promotion). Un processo attende per troppo tempo in una coda a bassa priorità. Viene spostato in una coda a priorità più alta. Questa è l'implementazione della tecnica di aging (invecchiamento). Previene la starvation , garantendo che anche i processi lunghi o a bassa priorità, prima o poi, ottengano l'accesso alla CPU. esempio concreto di un sistema MFQ a tre livelli.
- Coda Q0 (Massima Priorità): Tutti i nuovi processi entrano qui. L'algoritmo è Round Robin con un quanto di tempo q molto breve (es. 8ms). Se un processo finisce il suo lavoro in 8ms o meno , termina e lascia il sistema. Questo favorisce i processi interattivi molto corti.
Se un processo non finisce , allo scadere del tempo viene spostato nella coda sottostante, Q1.
- Coda Q1 (Priorità Media): Contiene i processi che non sono riusciti a terminare nel primo, breve quanto di tempo. L'algoritmo è ancora Round Robin , ma con un quanto di tempo q più lungo (es. 16ms). avviene la stessa cosa che è successa nella coda di prima.
- Coda Q2 (Minima Priorità): contiene i processi molto lunghi, chiaramente CPU-bound. L'algoritmo qui è First-Come, First-Served (FCFS). Un processo che arriva qui ottiene la CPU e la tiene finché non finisce o non si blocca per un I/O, senza essere interrotto da un timer.
