Sistemi operativi (teoria completa + domande)

La exec in realtà non è una singola system call ma una famiglia di system call.

Le più comuni sono:

• FILOSOFI A CENA

Un altro esempio di utilizzo dei semafori sono i cosiddetti semafori privati.

I semafori privati sono semafori dedicati ad un determinato thread che consente ad esso di sapere se può fare o meno una determinata operazione. Sono tanti quanti sono i thread che lavorano. Un thread prima di poter eseguire la sua operazione va a guardare questo semaforo assegnato a lui e se è verde la può fare, se è rosso qualche altro thread deve svegliarlo.

Facciamo un esempio effettuando la sincronizzazione di 5 filosofi a cena che alternano due attività: la prima è quella di pensare che possono fare senza chiedere il permesso agli altri (indipendente: non richiede alcun tipo di sincronizzazione) e la seconda è quella di mangiare. Per mangiare dal loro piatto devono usare 2 forchette ma le

stanno una alla sinistra e una alla destra del proprio piatto) e lo fanno attraverso due regioni critiche.

Supponiamo che quasi contemporaneamente tutti i filosofi finiscono di pensare e riescono tutti ad accedere alla propria forchetta sinistra, poi provano a prendere la forchetta destra.

Se tutti e 5 i filosofi si sono impadroniti della forchetta sinistra, le 5 forchette sono tutte impegnate e nessun filoso riesce a prendere la forchetta destra.

In questa situazione ci troviamo in una situazione di deadlock ed è una soluzione scorretta del problema.

La soluzione a questa situazione è la seguente che va implementata utilizzando isemafori. Essa consiste nel non provare a prendere separatamente la forchetta sinistra e destra, ma contemporaneamente. Quando un filosofo ha finito di mangiare, le lascia entrambe.

Andremo ad utilizzare un semaforo binario e un array di semafori. Ciascuno dei filosofi avrà un suo semaforo di riferimento che gli farà capire se può

mangiare; se quel semaforo privato suo è rosso deve aspettare che un altro degli altri semafori lo vada a svegliare. Le strutture di sincronizzazione sono: mutex (semaforo binario inizializzato a verde), un array di semafori privati, uno per ogni filosofo e una serie di variabili condivise che servono per capire che cosa sta succedendo.

Nell'i le e a i e dei d e e di e di_f che a() e la cia_f che a() ci ai a ll a a di i e i che c ie e e e g i fil f che e e e 0 1 o 2. a e e a l a ale a di a i i del fil f ( e il fil f a ella fa eQuesti interi di pensiero ci mettiamo in 0, se ha preso le due forchette e sta mangiando 2, se non ha ottenuto le due forchette ed è affamato 1). In questo array condiviso tutti i filosofi possono ca e c a a face d a . L a a c a c e c a e e c a LEFT e RIGHT che identificano una determinata forchetta. I nostri 5 filosofi sono identificati da un indice i e in base a questo indice riesco a capire quale è la sua forchetta destra e quella sinistra.

Le forchette sono etichettate con un numero. I filosofi vanno da 0 a 4 e anche le forchette sono identificate da un indice. Vediamo come lavorano questi due metodi. e_f() e _f() a c e a a e d ce de

Questi due metodi che sono tafilosofo che le esegue. Il filosofo zero per provare a capire se le sue forchette sono disponibili, la prima cosa che fa è attivare il metodo take_fork() con indice 0. La prima cosa che fa è assicurarsi di stare da solo e quindi di fare queste operazioni in mutua esclusione facendo un down del mutex.

Il suo stato cambia, da che stava pensando adesso è diventato affamato e attiva il metodo test. Non prende le forchette ma va prima a vedere se le forchette sono disponibili. Anche il metodo test ha un indice i, in questo caso 0.

Nel metodo test va a guardare 3 condizioni. La prima condizione sembrerebbe inutile e c ad a a da e e a affa a e ca e a c d esicuramente vera, ma siccome viene utilizzato anche per gli altri filosofi questa condizione non è

sempre vera. Dopo aver verificato questa condizione, va a guardare che cosastanno facendo i filosofi alla sua sinistra e alla sua destra.

Se sono 0 il filoso alla mia destra è 1 e quello alla mia sinistra è 4. LEFT e RIGHTa e e a d ce de f f a a a e a a de a.

Se uno dei due sta mangiando vuol dire che ha già preso una delle mie forchette o entrambe.

Se si verificano queste tre condizioni, il filosofo 0 è sicuro che le forchette che gli servono sono sul tavolo e le prende. Prenderle trasporta il filosofo 0 nello stato EATING (sta mangiando) e poi fa un up (mette la luce al verde) sul proprio semaforo privato contenutoe a a dei semafori privati (i semafori sono tutti inizializzati a rosso).

Questo up va fatto perché poi dopo nel metodo take_fork() vado a rimettere a zero tramited () e af a e a a a a e. Se a e e fa , e afpersonale non andava ad 1 e quando dopo faceva il down() il semaforo privato era già a zero e andava in wait() (ricordarsi la classe semaforo).

entrambe le forchette. Chi li sveglierà?

Il filosofo 1 sarà svegliato dal filosofo 0 quando ha finito di mangiare perché quando ha finito il filosofo 0 esegue il metodo put_fork() con indice 0.

Il filosofo 0, in questo metodo ha finito di mangiare e vuole rimettersi a pensare. La prima cosa che fa è provare ad accedere alla regione critica che prova a modificare lo stato attuale di tutti i filosofi. Se ci riesce modifica il suo stato e va a fare un test sul filosofo alla sua sinistra e alla sua destra (non più su se stesso).

Il test sul filosofo 4, ovvero quello alla sinistra del filosofo 0. Se il filosofo alla sua sinistra non è HUNGRY, è inutile andare a guardare le altre cose e che ha bisogno di una forchetta (del filosofo 0) e fa il check se il filosofo 0 ha la forchetta sinistra e la lascia sul tavolo; quando poi il filosofo 4 la vorrà utilizzare lo farà.

I filosofi 1 e 2

Prima di uscire il test va fatto anche sul filosofo 1 (RIGHT) forchetta alla

sua sinistra ma non poteva prenderla perché quello 0 stava mangiando. Il filosofo 0 e 1 affamati e che la forchetta a sinistra sia disponibile, ma anche quella a destra deve essere disponibile e che lo stato del filosofo 2 sia diverso da EATING. A questo punto lo stato del filosofo 1 viene settato da quello 0 a EATING e poi sempre il filosofo 0 va a svegliare il semaforo privato del filosofo 1; stava in wait() quindi viene svegliato. Il processo viene ripetuto indefinitamente perché nel metodo main abbiamo un while(TRUE).

invece di usare l'interno pathname. È un intero maggiore di zero. A Lo standard input è un canale standard da cui giunge un flusso di dati in ingresso al programma. Il programma li trasferisce effettuando operazioni di lettura. Il file descriptor ad esso associato è 0.

Lo standard output è un canale standard su cui un programma scrive i suoi dati in output.

Ogni casella tiene memorizzato un carattere. Il terzo parametro indica il numero di byte da leggere dal buffer di caratteri (array di caratteri) e da scrivere nel file. Restituisce il numero di byte scritti nel file oppure restituisce -1 in caso di errore. Se non richiamo questa system call, quando viene aperto un file, il cursore è impostato di default all'inizio del file. Se per caso dopo una open si vuole scrivere con una write, le stringhe che verranno scritte nel file verranno scritte all'inizio del file, sovrascrivendo le prime stringhe e lasciando inalterate le restanti se sono presenti. Restituisce la posizione del file attuale dopo l'effetto della system call. Restituisce -1 in caso di errore.

Esempio di traduzione da indirizzo logico ad indirizzo fisico:

Vogliamo trasformare un indirizzo logico di bit in un indirizzo fisico che andrà sull'address bus costituito da 15 bit. Abbiamo la nostra memoria virtuale di 64k.