Prova teorica 2013.07.19 - Revision history

FedericoB: /* Esercizio g.1 */

2017-05-09T12:04:57Z

Esercizio g.1

S.G: Esercizio scheduler

2016-12-19T17:35:03Z

Esercizio scheduler

S.G: Esercizio monitor e semafori

2016-12-19T16:17:24Z

Esercizio monitor e semafori

New page

Testo: [http://www.cs.unibo.it/~renzo/so/compiti/2013.07.19.tot.pdf]

== 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.

<syntaxhighlight lang="C">
#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;
}
}
</syntaxhighlight>
[[User:S.G|S.G]] ([[User talk:S.G|talk]]) 17:17, 19 December 2016 (CET)

== Esercizio c.2 ==
'''Testo esercizio'''
{| class="wikitable"
|-
|
<syntaxhighlight lang="C">
shared val = 0;
shared Semaphore sp = new Semaphore(1);
shared Semaphore sq = new Semaphore(1);
shared Semaphore mutex = new Semaphore(1);
</syntaxhighlight>
|
<syntaxhighlight lang="C">
process P {
int kp = 3;
while (kp > 0) {
sp.P();
mutex.P();
val = val+1;
sq.V();
mutex.V();
kp--;
}
}
</syntaxhighlight>
|
<syntaxhighlight lang="C">
process Q {
int kq = 2;
while (kq > 0) {
sq.P();
mutex.P();
val = val*2;
sp.V();
mutex.V();
kq--;
}
}
</syntaxhighlight>
|}
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.

[[User:S.G|S.G]] ([[User talk:S.G|talk]]) 17:17, 19 December 2016 (CET)

← Older revision		Revision as of 12:04, 9 May 2017
Line 149:		Line 149:
	</syntaxhighlight>		</syntaxhighlight>
	[[User:S.G\|S.G]] ([[User talk:S.G\|talk]]) 18:35, 19 December 2016 (CET)		[[User:S.G\|S.G]] ([[User talk: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. --[[User:FedericoB\|FedericoB]] ([[User talk:FedericoB\|talk]]) 14:04, 9 May 2017 (CEST)
		+
		+	//TODO: aggiungere evoluzione ready queue nel tempo.

← Older revision		Revision as of 17:35, 19 December 2016
Line 122:		Line 122:

	[[User:S.G\|S.G]] ([[User talk:S.G\|talk]]) 17:17, 19 December 2016 (CET)		[[User:S.G\|S.G]] ([[User talk: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''
		+	<syntaxhighlight lang="C">
		+	+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
		+	\| \| 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 \| \| \| \|
		+	+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
		+	</syntaxhighlight>
		+	[[User:S.G\|S.G]] ([[User talk:S.G\|talk]]) 18:35, 19 December 2016 (CET)