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.