Prova Teorica 2011.05.13

Esercizio 1

Scrivere un monitor reqq che gestisca Ncode di richieste.
I richiedenti chiamano la funzione che ha la seguente signature:
answer_t reqq.query(request_t request, int type);
Query deve fermare il processo richiedente fino a completamento della richiesta da parte di un gestore. Il valore di ritorno
e' la risposta del gestore.
Ci sono N gestori, uno per ogni tipo di richiesta, che si comportano come segue:
multiq_handler: process[i, i=0,..,N-1] {
  request_t req;
  int type;
  while (1) {
    req=reqq.getquery(i, &type);
    reqq.reply(i,handle(req, type));
  }
}
Normalmente le richieste vengono assegnate al gestore del tipo corrispondente (i==type), se non vi sono richieste di tale
tipo elabora una richiesta del tipo con la piu' lunga coda di richieste pendenti. Quando un gestore termina l'elaborazione
(funzione handle, da non implementare!) invia il risultato tramite la reply. Il valore passato alla reply deve essere restituito
al richiedente come valore di ritorno della funzione query. Se non vi sono richieste disponibili i gestori si fermano
attendendo nuove richieste.

// ------------------------------- SOLUZIONE DI MV ----------------------------------------

monitor reqq
{
	queue Q[N];	// array di N code
	answer_t A[N];	// variabili per salvare temporaneamente le risposte dei gestori
	condition notempy[N];	// ci si fermano i gestori se la risp. coda è vuota
	condition done[N];	// ci si fermano i processi in attesa della risposta
	int n_req[N];	// num. di richieste per ogni coda
	
	answer_t query(request_t request, int type)
	{
		Q[type].enqueue(request);
		n_req[type]++;
		notempy.signal();
		done.wait();
		return A[type];
	}
	
	request_t getrequest(int i, int* type)
	{
		*type = i;
		if(n_req[N] == 0)
			notempy.wait();
		return Q[i].dequeue();
	}
	
	void reply(int type, answer_t answer)
	{
		A[type] = answer;
		done.signal();
	}
}

Ho provato a risolverlo pur non avendo ben capito una frase ("se non vi sono richieste di tale tipo elabora una richiesta del tipo con la piu' lunga coda di richieste pendenti"). Se notate errori avvisatemi!

// ------------------------------- SOLUZIONE DI Maldus ----------------------------------------
monitor reqq{
	request_t queue Q[N];	
	condition[] done = new condition[N];	
	condition notempty;	// una sola condizione per controllare quando la coda delle richieste è vuota;
	answer_t A[N];
	int longest;

	reqq(){
		longest = 0 ;
	}

	procedure entry answer_t query( request_t request, int type){
		Q[type].enqueue(request);
		if( Q[type].lenght() > Q[longest].lenght() ) longest = type;
		notempty.signal();
		done[type].wait();
		return A[type];
	}

	procedure entry request_t getquery( int i, int* type){
		if( Q[i].empty() ){
			if( longest == 0 ) notempty.wait();
			i = longest;
		}
		*type = i ;
		return Q[i].dequeue();
	}

	procedure entry void reply( int type, answer_t answer){
		A[type] = answer;
		done.signal();
	}

Interpreto la frase "se non vi sono richieste di tale tipo elabora una richiesta del tipo con la piu' lunga coda di richieste pendenti" considerando appunto il tipo per il quale ci sono più richieste ( se quello specificato invece non ne ha) nella funzione getquery: in quest'ottica ho pensato che la condizione notempty dovesse essere singola, perchè se un gestore può gestire anche una richiesta diversa dal tipo specificato, non importa quale richiesta viene aggiunta. Per il resto è praticamente identico alla soluzione di MV.