esercizio del 09/12/2009

numero 1
siano dati tre processi "stampa" come segue:
stampa(x):(x=A,T,R) process
while (true) {
	taratata.synchro(x);
	print(x);
}
scrivere il monitor taratata con una sola procedure entry synchro() che consenta di avere in output una sequenza infinita di TARATATA (i.e. TARATATATARATATATARATATATARATATA...)

condition okX[1, 2, 3]
int state;
sharp.d = msg[8] = {T, A, R, A, T, A, T, A}

while (true)
	taratata.enter(x);
	print(x);
	taratata.exit(x);


p. entry enter(x)
	if (msg[state] != x)
		okX[x].wait();

p. entry exit(x)
	state = (state+1)%&;
	okX[msg[state]].signal();

potendo unire exit ed enter
p. entry
if (notfirst[x]) {
	state = (state+1)%&;
	okX[msg[state]].signal();
}
notfirst[x]=true;
if (msg[state]!=x)
	okX[x].wait();


-------------------------------------------------------------------------------------------

numero 2
Uno scheduler cooperativo prevede che ogni processo chiami la funzione yield() quando può cedere il controllo agli altri processi.
La funzione yield deve quindi attivare un altro processo e bloccare il chiamante.
Facendo uso di semafori scrivere tre funzioni init, yield, fini tutte prive di parametri.
Init viene chiamata da un processo che vuole iniziare la propria esecuzione, yield è quella descritta sopra e fini viene chiamata da un processo
subito prima di terminare.
Un solo processo alla volta deve essere in esecuzione (fra quelli che hanno chiamato init e non ancora fini), yield deve fare avvicendare i processi
in ordine ciclico (come se fossero in una coda circolare, il processo che fa yield deve essere riattivato dopo che tutti quelli in attesa hanno avuto
modo di essere eseguiti e chiamare nuovamente yield o fini).

semaphore.mutex(1)
init
mutex.P();
yield();
mutex.V();
mutex.P();
fini
mutex.V();