Prova teorica 2013.07.19

Testo: [1]

Esercizio c.1

Testo esercizio

Scrivere un monitor mvie che gestisca M buffer limitati. Ogni buffer ha l'ampiezza di MELEM elementi. I produttori chiamano la procedure entry: put(generic *object) mentre i consumatori chiamano la procedure entry generic *get(int n) I produttori conferiscono un vettore di M elementi, uno per ogni buffer al buffer. Per esempio put(v), (dove v e' un vettore di M elementi) inserisce ogni elemento del vettore nel buffer corrispondente. I consumatori ricevono un oggetto dal buffer indicato come parametro oggetti ma attendono sempre che ci sia almeno un elemento in ogni buffer.

#define M
#define MELEM
monitor mvie{
	generic buffer[][];
	int front, count, bufelem[];
	condition P, C[];
	
	void mvie(void){
		buffer = new generic[M][MELEM];
		bufelem = new int[M];
		front = count = 0;
		for(i=0; i<M; i++)
			bufelem[i] = 0;
		C = new condition[M];
	}
	
	void put(generic *obj){
		int i, w;
		if(count > M)
			P.wait();
		
		count++;
		for(i=0; i<MELEM; i++)
			buffer[front][i] = obj[i];
		bufelem[front] = MELEM;
		w = front;
		front = (front + 1) % M;
		C[w].signal();
	}
	
	generic *get(int n){
		int i;
		generic ret = new generic[MELEM];
		if(bufelem[n] <= 0)
			C[n].wait();
		
		count--;
		for(i=0; i<MELEM; i++)
			ret[i] = buffer[n][i];
		bufelem[n] = 0;
		P.signal();
		return &ret;
	}
}

S.G (talk) 17:17, 19 December 2016 (CET)

Esercizio c.2

Testo esercizio

shared val = 0; shared Semaphore sp = new Semaphore(1); shared Semaphore sq = new Semaphore(1); shared Semaphore mutex = new Semaphore(1);

process P { int kp = 3; while (kp > 0) { sp.P(); mutex.P(); val = val+1; sq.V(); mutex.V(); kp--; } }

process Q { int kq = 2; while (kq > 0) { sq.P(); mutex.P(); val = val*2; sp.V(); mutex.V(); kq--; } }

a) Al termine di questo programma, quali sono i valori possibili della variabile condivisa val?

b) E' possibile che i processi P o Q restino bloccati indefinitamente?

Svolgimento

a) I valori possibili della variabile condivisa val dipendono dall'arrivo temporale dei due processi:

- PQPQP: val = 7

- QPQP: val = 3

b) Il processo P può rimanere bloccato in due casi:

- Non arrivi mai il processo Q;

- Il primo processo della sequenza sia Q, generando la sequenza QPQP;

Di conseguenza P non completerebbe mai il suo compito.

Il processo Q può rimanere bloccato solo in un caso, cioè quando non arrivi mai il processo P.

S.G (talk) 17:17, 19 December 2016 (CET)

Esercizio g.1

Testo esercizio

Siano dati i processi P1, P2 e P3 in ordine descrescente di priorita' (P1 ha massima priorita' e P3 minima).

P1: CPU 2ms, I/O 1ms, CPU 2ms, I/O 2ms, CPU 2ms

P2: CPU 3ms, I/O 2ms, CPU 3ms, I/O 2ms, CPU 3ms

P3: CPU 1ms, I/O 1ms, CPU 1ms, I/O 1ms, CPU 1ms

I tre processi usano la stessa unita' per l'I/O (le richieste di I/O vengono gestite in ordine FIFO)

Si calcoli il diagramma di Gannt (descrivendo il procedimento) per uno scheduler round robin con time slice 2ms.

Svolgimento

+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
|    | 1  | 2  | 3  | 4  | 5  | 6  | 7  | 8  | 9  | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 |
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
|CPU | P1 | P1 | P2 | P2 | P3 | P1 | P1 | P2 | P3 | P1 | P1 | P2 | P2 | P3 | P2 |    |    | P2 | P2 | P2 |
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
|I/O |    |    | P1 |    |    | P3 |    | P1 | P1 | P2 | P2 | P3 |    |    |    | P2 | P2 |    |    |    |
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+

S.G (talk) 18:35, 19 December 2016 (CET)

Soluzione corretta, abbiamo svolto l'esercizio in aula. Attenzione però che nel testo c'è un refuso, la priorità non è da considerare in quando è uno scheduler round robin. P1,P2,P3 è la situazione iniziale della coda ready. --FedericoB (talk) 14:04, 9 May 2017 (CEST)

//TODO: aggiungere evoluzione ready queue nel tempo.