Prove scritte 2023

Parziale 2023/01/20

Esercizio c1

Scrivere il monitor fullbuf che abbia le seguenti procedure entry:

void add(int value)
int get(void)

Le prime MAX chiamate della procedure entry add devono bloccare i processi chiamanti. In seguito deve sempre valere Na >= MAX indicando con Na il numero di processi bloccati in attesa di completare la funzione add. La funzione get deve attendere che Na > MAX, restituire la somma algebrica dei parametri value delle chiamate add in sospeso e riattivare il primo processo in attesa di completare la add (se la get richiede che Na > MAX, la get può riattivare un processo e al completamento della get si rimarrà garantito che Na >= MAX)

Soluzione proposta 1 (da controllare)

Proposta da SpookyWiki (talk) 17:39, 17 May 2023 (CEST)

monitor fullbuf {
	int MAX; //numero massimo di proc che devono essere bloccati sul buffer
	int Na;
	int mem;

	condition wait4get;
	condition wait4add;

	fullbuf(int max) {
		MAX = max;
		Na = 0;
		mem = 0;
	}

	procedure entry void add(int value) {
		Na++;                   //mi segnalo in attesa

		if( Na > MAX ) {        //se ci sono abbastanza processi in attesa
			wait4add.signal();  //attivo la get

		wait4get.wait();        //mi metto effettivamente in attesa
		mem = value;            //metto a disposizione il mio valore
	}

	procedure entry int get(void) {
		if ( !(Na > MAX) )      //se non ci sono abbastanza get in attesa
			wait4add.wait();    //mi metto in attesa

		int result = 0; 

		while( Na > MAX ) {     //finchè c'è un surplus di add in attesa
			wait4get.signal();  //riattivo il primo add in attesa
			result += mem;      //prendo il suo valore
			Na--;
		}
		return result;
	}

}

Esercizio c2

Dato un servizio di message passing asincrono implementare un servizio di message passing sincrono a scambio che prevede una sola chiamata:

T xchange(T msg, pid_t dest) 

dove T è un tipo generico (potrebbe essere int, string, struct mystruct). Il parametro dest non può essere ANY. Quando il processo P chiama xchange(m1, Q) e il processo Q chiama xchange(m2, P) entrambi i processi vengono riattivati, la xchange chiamata da P restituirà m2 mentre la xchange di Q restituirà m1.

Soluzione proposta 1

Proposta da SpookyWiki (talk) 16:55, 17 May 2023 (CEST)

T xchange(T msg, pid_t dest) { 
    asend(msg, dest); 
    return arecv(dest); 
}

Prova 2023/01/18

Esercizio c1

Scrivere il monitor synmsg che consenta uno scambio di messaggi fra due processi in maniera sincrona. Il processo produttore esegue il seguente codice.

producer: process:
 while True:
  msg_t msg = produce_new_msg()
  synmsg.send(&msg)

e il processo consumatore:

producer: process: while True:
 msg_t msg synmsg.recv(&msg) 
 consume_msg(&msg)

Come si vede le procedure entry hanno come parametro l'indirizzo del messaggio:

procedure entry void send(msg_t *msg)
procedure entry void recv(msg_t *msg)

Il monitor deve trasferire il contenuto del messaggio direttamente fra i processi usando la funzione:

void copymsg(msg_t *src, msg_t *dest)

(Il monitor non deve avere buffer di tipo msg_t ma solo variabili di tipo puntatore a msg_t.)

Soluzione proposta 1

Proposta da SpookyWiki (talk) 16:55, 17 May 2023 (CEST)

monitor synmsg {
	msg_t *address;

	int waiting2send;
	int waiting2recv;

	condition waiting4sender;
	condition waiting4recvr;

	synmsg() {
		address = NULL;
		waiting2send = 0;
		waiting2recv = 0;
	}

	procedure entry void send(msg_t *msg) {
		if ( waiting2recv == 0) {
			waiting2send++;
			waiting4recvr.wait();
			waiting2send--;
			copymsg(msg, address);
		} else {
			address = msg;
			waiting4sendr.signal()
			address = NULL;
		}
	}

	procedure entry void recv(msg_t *msg) {
		if ( waiting2send == 0) {
			waiting2recv++;
			waiting4sendr.wait();
			waiting2recv--;
			copymsg(address, msg);
		} else {
			address = msg;
			waiting4recvr.signal();
			address = NULL;
		}
	}
}