Riassunto Sistemi operativi

L'obiettivo della partizione del tempo

L'obiettivo della partizione del tempo è di commutare l'uso della CPU tra i vari processi in modo frequente, in modo che gli utenti possano interagire con ciascun programma mentre è in esecuzione. Lo scheduler dei processi seleziona un processo da eseguire dall'insieme di quelli disponibili.

Ogni processo è inserito nella coda dei processi pronti mentre i processi presenti in RAM che sono pronti e in attesa di essere eseguiti si trovano in una lista detta coda dei processi pronti. Quando si assegna la CPU a un processo, rimane in esecuzione per un certo periodo di tempo, poi o termina o rimane in attesa di qualche evento particolare.

Un nuovo processo si colloca nella coda dei processi pronti dove attende finché non viene selezionato per l'esecuzione (dispatched). Una volta che il processo è assegnato alla CPU ed è nella fase di esecuzione, si può verificare uno dei seguenti eventi:

• Il processo emette una richiesta di I/O;
• Il processo...

può creare un nuovo processo e attenderne la terminazione; Processo può essere rimosso forzatamente dalla CPU a causa di un'interruzione ed essere reinserito nella coda dei processi pronti. Nel corso della sua esistenza, un processo si trova in varie code di scheduling. Il SO compie la selezione x mezzo di uno scheduler. Spesso accade che si sottopongano più processi di quanti se ne possano eseguire immediatamente. Questi lavori si trasferiscono in memoria secondaria dove si tengono fino al momento dell'esecuzione. Lo scheduler a lungo termine sceglie i lavori da questo insieme e li carica nella RAM affinché siano eseguiti mentre lo scheduler a breve termine fa selezione tra i lavori pronti e assegna la CPU a uno di loro in maniera molto frequente e rapida mentre lo scheduler a lungo termine si esegue con una frequenza molto inferiore. Quest'ultimo controlla il grado di multiprogrammazione, cioè il numero di processi presenti in memoria. Seè stabile, la velocità media di creazione dei processi deve essere uguale alla velocità media con cui i processi abbandonano il sistema quindi questo scheduler può essere richiamato solo quando un processo abbandona il sistema, inoltre deve fare una accurata selezione dei processi tra processi con prevalenza di 1/O e processi con prevalenza d'elaborazione. I primi richiedono prevalenza di I/O ei secondi prevalenza di CPU. Lo scheduler a lungo termine deve selezionare una buona combinazione di processi tra questi ultimi. In alcuni sistemi operativi si può introdurre lo scheduler a medio termine. Quest'ultimo viene introdotto per eliminare processi dalla memoria per ridurre il grado di multiprogrammazione e successivamente essere reintrodotti in memoria in modo che l'esecuzione riprenda da dove era stata interrotta. Questo metodo viene chiamato swapping o avvicendamento. Il processo viene rimosso e successivamente caricato in memoria dallo scheduler a medio termine.

presenza di un'interruzione, il sistema deve salvare il contesto del processo corrente. Il contesto è rappresentato all'interno del PCB del processo e in termini generali si effettua un salvataggio dello stato corrente della CPU; in seguito di effettuerà un corrispondente ripristino dello stato. Questa procedura è nota col nome di cambio di contesto o context switch. Nell'evenienza di un context switch, il sistema salva nel suo PCB il contesto del processo uscente e carica il contesto del processo subentrante. Il cambio di contesto comporta una calo delle prestazioni.

3.3 Operazioni sui processi

Durante la propria esecuzione, un processo può creare numerosi altri processi tramite l'apposita chiamata create process. Il processo creante si chiama genitore mentre quello creato si chiama figlio. Ciascun processo può creare altri processi formando il cosiddetto albero dei processi. La maggior parte dei so identifica il processo con

un valore diverso da zero nel processo genitore. Questo valore diverso da zero è l'identificativo del processo figlio (PID). Il processo genitore può decidere di condividere alcune risorse con i suoi processi figli o di spartire le proprie risorse tra di essi. Quando un processo crea un nuovo processo, ci sono due modi per gestire l'esecuzione: 1. Il processo genitore continua l'esecuzione in modo concorrente con i propri processi figli. 2. Il processo genitore attende che alcuni o tutti i figli terminino prima di proseguire. Anche per lo spazio di indirizzi del nuovo processo ci sono due possibilità: 1. Il processo figlio è un duplicato del processo genitore, condividendo lo stesso spazio di indirizzi. 2. Nel processo figlio viene caricato un nuovo programma, creando un nuovo spazio di indirizzi. In Unix, un nuovo processo si crea utilizzando la chiamata di sistema fork(). Entrambi i processi (genitore e figlio) continuano l'esecuzione dalla riga successiva alla chiamata di sistema fork(), ma con una differenza: la chiamata di sistema fork() restituisce il valore zero nel nuovo processo (figlio), mentre restituisce un valore diverso da zero nel processo genitore. Questo valore diverso da zero è l'identificativo del processo figlio (PID).motivi, ad esempio se il figlio ha terminato il suo compito o se si è verificato un errore durante l'esecuzione. Per porre fine all'esecuzione di un processo figlio, il genitore può utilizzare la chiamata di sistema kill() specificando l'identificatore del processo figlio come argomento. In questo modo il processo figlio viene terminato e tutte le sue risorse vengono liberate dal sistema operativo.motivi:

• Il processo figlio ha ecceduto nell'uso di alcune tra le risorse che gli sono state assegnate. Ciò richiede che il processo genitore disponga di un sistema che controlli lo stato dei figli;
• Il compito assegnato al processo figlio non è più richiesto;
• Il processo genitore termina e il sistema operativo non consente a un processo figlio di continuare l'esecuzione.

Infine, se un processo genitore termina, tutti i suoi processi figli sono affidati al processo init() che assume il ruolo di nuovo genitore, cui i processi figli possono riportare i risultati delle proprie attività.

3.4 Comunicazione tra processi

I processi eseguiti concorrentemente nel sistema operativo possono essere indipendenti o cooperanti. Un processo è indipendente se non può influire su altri processi del sistema o subirne l'influsso, invece un processo è cooperante se influenza o può essere influenzato da altri processi. Un ambiente che consente la cooperazione puòessereutile x diverse ragioni: condivisione di info, accelerazione di calcolo, modularità e convenienza. X lo scambio di dati e info i processi cooperanti necessitano di un meccanismo di comunicazione tra processi ed esistono 2 tipi: (1) memoria condivisa e (2) scambio di messaggi. Nel primo si stabilisce una zona di memoria condivisa dai processi cooperanti, che possono così comunicare scrivendo e leggendo quella zona mentre nel secondo la comunicazione ha luogo con uno scambio di messaggi tra processi. Quest'ultimo è molto utile nel trasmettere piccole quantità di dati mentre la memoria condivisa massimizza l'efficienza della comunicazione ed è più veloce. Nei sistemi a memoria condivisa la comunicazione tra processi richiede una zona di memoria condivisa. Normalmente il so tenta di impedire a un processo l'accesso in memoria di altri processi, infatti questo metodo richiede che due o più processi raggiungano un accordo x superare tale limite.

Il tuo compito è formattare il testo fornito utilizzando tag html.

ATTENZIONE: non modificare il testo in altro modo, NON aggiungere commenti, NON utilizzare tag h1;

in modo da poter comunicare tramitescritture e letture dell'area condivisa, avendo inoltre la responsabilità di non scrivere inmemoria in maniera simultanea.

I sistemi a scambio di messaggi permettono a due o più processi di comunicare esincronizzarsi senza condividere lo stesso spazio di indirizzi. Questo meccanismo deveprevedere almeno due operazioni: send e receive x inviare e ricevere il messaggio. Trai processi comunicanti vi deve essere un canale di comunicazione implementato alivello logico nei seguenti modi:

1. Comunicazione diretta o indiretta;
2. " " sincrona o asincrona;
3. Gestione automatica o esplicita del buffer.

Con la comunicazione diretta, ogni processo che intende comunicare deve nominareesplicitamente il ricevente o il trasmittente della comunicazione (send(P, sms) - inviasms al processo P). All'interno di questo schema un canale di comunicazione ha leseguenti caratteristiche:

• Tra ogni coppia di processi si stabilisce un canale e i

processi stessi conoscono la reciproca identità;

Un canale è associato a due processi. Con la comunicazione indiretta, i messaggi si inviano a delle porte che li ricevono. Due processi comunicano solo se condividono una porta (send(A, sms) - invia sms alla porta A). All'interno di questo schema un canale di comunicazione ha le seguenti caratteristiche:

• Tra i processi si stabilisce un canale solo se condividono una stessa porta;
• Un canale può essere associato a più processi;
• Tra ogni coppia di processi possono esserci più canali diversi ciascuno corrispondente a una porta.

Lo scambio di messaggi può essere anche sincrono e asincrono:

• Invio sincrono: il processo che invia il messaggio si blocca nell'attesa che il processo ricevente, o la porta, riceva il messaggio;
• Invio asincrono: il processo invia il messaggio e riprende la propria esecuzione;
• Ricezione sincrona: il ricevente si blocca nell'attesa di arrivo di un messaggio.

messaggio;

• Ricezione asincrona: il ricevente riceve un messaggio valido oppure un valore nullo. Se la comunicazione è diretta o indiretta, i messaggi risiedono in code temporanee. Esistono tre modi per realizzare queste code:
• Capacità zero: la coda ha lunghezza massima zero quindi il canale non può avere messaggi in attesa al suo interno. In questo caso il trasmittente deve fermarsi finché il ricevente prende in consegna il messaggio (senza memorizzazione transitoria - no buffering)
• Capacità limitata: la coda ha lunghezza finita n, quindi al suo interno non possono esserci più di n messaggi
• Capacità illimitata (memorizzazione transitoria automatica - automatic buffering)

Capitolo 4

4.1 Introduzione

Un thread è un percorso di controllo ed è l'unità di base d'uso della CPU e comprende un identificatore di thread (ID), un contatore di programma, un insieme di registri e una pila (stack). Condividono con gli

ano nel contesto del programma principale.