Merge pull request #42 from LiberaLongo/main

ricevimento 2023 luglio 05

prove/scritto/scritto-2017-05-29-soluzione-c1prof.txt

@@ -0,0 +1,45 @@
+//ricevimento 2023 07 05 (luglio)
+
+int npronti = 0
+condition tuttipronti;
+int gnumeri = [];
+condition ok2play[MAX]
+int nallabandiera
+int[2] punteggio;
+
+def nuovapartita():
+	punteggio[A]=0;
+	punteggio[B]=0;
+
+def chiama(squadra, numeri): //numeri è un vettore di interi
+	if (npronti < 2 * MAX) tuttipronti.wait()
+	gnumeri = numeri;
+	nallabandiera = 0
+	//tutti a casa! (se è finita la partita signal a tutti)
+	if max(punteggio) >= 10
+		for n in range(MAX):
+			ok2play[n].signal()
+			ok2play[n].signal()
+	else
+	//si gioca
+	for n in numeri:
+		ok2play[n].signal()
+		ok2play[n].signal()
+	return punteggio
+
+def pronto(squadra, numero):
+	npronti++;
+	if (npronti == 2 * MAX) tuttipronti.signal();
+	if (max(punteggio) >= 10) return 1; //esci se è finita la partita
+	//lascieranno la pronti solo gli studenti che vengono chiamati
+	if (not numero in gnumeri) //se non sono chiamata aspetto
+		ok2play[numero].wait;
+	npronti--;
+	return 0
+
+def allabandiera(squadra, numero):
+	//l'ultimo che arriva alla bandiera ha perso, fa sempre parte della squadra perdente
+	nallabandiera++
+	if (nallabandiera == 2 * len(gnumeri)
+		punteggio[1-squadra] ++ //l'altra squadra ha vinto
+

prove/scritto/scritto-2017-06-19-soluzione-c1prof.txt

@@ -0,0 +1,48 @@
+//ricevimento 2023 07 05 (luglio)
+
+Monitor giav{
+condition ok2tiro[NATLETI] ok2lanciato;
+int conta[NATLETI] = {0,…,0}
+int next = 0
+bool lanciok;
+int count = 0;
+
+boolean pronto(i){
+	if(conta[i]<=3){
+		if (next != i)
+			ok2tiro.wait();
+		return true;
+	} else {
+		return false;
+	}
+	lanciok=false
+}
+
+void lanciato(i){
+	lanciok=true;
+	ok2lanciato.signal();
+	conta[i]++;
+}
+
+int lanciofatto(){
+	if (not lanciok)
+		ok2lanciato.wait();
+	current = next;
+	next = (next + 1) % NATLETI;
+	count++;
+	if (count >= 3 * NATLETI)
+		return -1;
+	else
+		return current;
+}
+
+void registraechiama(i, m){
+	ranking.add(i,m);
+	ok2tiro[next].signal();
+}
+
+Queue classifica(){
+	//ordina in modo decrescente la classifica in base al secondo parametro (la misura)
+	c = ranking.orderByM(class);
+	return c;
+}

prove/scritto/scritto-2017-06-19-soluzione-c2prof.txt

@@ -0,0 +1,64 @@
+//ricevimento 2023 07 05 (luglio)
+
+foo(a,b,c): <if (random(0,1)) {a=b; b=c} else {c=b; b=a}>
+
+x = 0
+foo (x,y,x)
+setto x al valore precedente di y
+y=x? abbiamo fatto un assegnamento atomico in un mondo in cui non lo è
+
+x=y=1
+foo(x,g,y)
+se g = 1 x e y = 1
+se g = 0 allora uno delle due (x o y) = 0 l'altro rimane 1 e g diventa 1
+
+x=y=0
+foo(x,g,y) allora g=0
+
+mutexin:
+    while True:
+        x=y=1;
+        foo(x,g,y)
+        if (x == 0 || y == 0) break;
+
+mutexout
+     x=y=0
+     foo(x,g,y)
+
+-------------------
+bar(a,b): <x=a & 1; a = (a >> 1) | b << 31; b = x>
+
+ bar(a,b) è un registro di scorrimento infatti
+hmmmmmmmmmmmmmml
+restituisce l
+bhmmmmmmmmmmmmmm
+
+0 sarebbe via libera, != 0 sarebbe continua a ciclare
+a come globale b come locale
+v=0
+bar (g, v)
+v=1
+for i in range(31): bar(g, v)
+
+mutexin:
+    do
+       v=1
+       bar(g,v)
+    while v != 0
+
+mutexout:
+    v=0
+    bar(g,v)
+
+11111110
+entra
+11111111 v=0
+entra
+11111111 v=1
+esce
+01111111 v=1
+
+quello che voleva entrare
+10111111 v =1
+11011111 v=1
+continua a ciclare finchè non fa v=0

prove/scritto/scritto-2017-07-17-soluzione-c1elena.txt

@@ -0,0 +1,43 @@
+//ricevimento 2023 07 05 (luglio)
+//proposta da Elena e controllata dal prof
+
+Monitor conf{
+	Set nonPresenti = new Set(); //insieme di quelli non presenti
+	Queue <condition, string> relatori = new Queue();
+	condition ok2presentazione;
+
+	bool chiama(chiamato){
+		//se trova il chiamato nella coda relatori, restituisce la condition corrispondente
+		//sblocca il chiamato e aspetta finisca la presentazione
+		if(find(relatori, chiamato)){
+			c = find(relatori, chiamato).second;
+			c.signal();
+			ok2presentazione.wait();
+			return true;
+			// sennò inserisce il chiamato tra i non presenti e restituisce false
+		} else {
+			nonPresenti.insert(chiamato);
+			return false;
+		}
+	}
+
+	bool arrivato(nome){
+		//se il nome è tra i chiamati e non presenti restituisce false
+		//sennò aspetta di essere chiamato
+		if(found(nonPresenti, nome)){
+			nonPresenti.delete(nome);
+			return false;
+		} else {
+			c = new condition;
+			relatori.enqueue(c, nome);
+			c.wait();
+		}
+	}
+
+	void finepresentazione(nome){
+		//rimuove dalla lista dei relatori quello che ha finito e segnala la fine della presentazione
+		relatori.dequeue(nome);
+		ok2presentazione.signal();
+	}
+}
+

prove/scritto/scritto-2017-07-17-soluzione-c2libera.txt

@@ -0,0 +1,38 @@
+//ricevimento 2023 07 05 (luglio)
+//proposta da Libera e controllata dal prof
+
+//questa proposta era già su wiki a questo link:
+// https://so.v2.cs.unibo.it/wiki/index.php/Prove_scritte_2017#Esercizio_c.2_.28da_controllare.29_2
+
+//il messaggio mandato è la tripla <destinatario, mittente, messaggio>
+
+asend(pid_t dst, msg_type msg){
+	bsend (<dst, getpid(), msg>);
+}
+
+myDictionaryQueue of <pid_t, msg_type> db; //nota: salvo qui solo se il messaggio è per me, quindi dest non mi serve
+
+arecv(pid_t sender) {
+
+	//devo controllare se nella db ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
+	//db.get(sender) cerca una coppia il cui mittente è sender
+	//se trova il messaggio lo rimuove anche dal db.
+	//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;
+
+	if( ( <mit, msg> = db.get(sender) ) != NULL ) //se lo trova
+		return msg;
+
+	do {
+		<dst, mit, msg> = brecv(*);				//ricevo
+		if( dst == getpid() ) {					//il messaggio è per me?
+			if ( mit == sender || sender == ANY )		//se devo ritornare il messaggio
+				return msg;     //esci dal while
+
+			//se devo salvarlo (sender specificato e messaggio per me)
+			//metto in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
+
+			db.add(<mit, msg>);
+		}
+		//se il messaggio non era per me non devo farci niente, quindi lo butto via!
+	} while ( true ) //devo uscire solo con il return
+}

prove/scritto/scritto-2020-01-15-soluzione-c1simone.txt

@@ -0,0 +1,43 @@
+//ricevimento 2023 07 05 (luglio)
+//proposta da Simone e controllata dal prof
+
+monitor semtimeout() {
+	int init = 0; //nei positivi = value, nei negativi = quanti sono in attesa
+	List (Int, Condition) processes;
+	bool activatedByTimeout = false;
+
+	public void entry V(void) {
+		init++;
+		processes.head().second.signal(); // secondo campo della testa di process --> la condizione
+		processes.remove(process);
+	}
+
+	public boolean entry P(unsigned int timeout) {
+		init--;
+		if(init < 0) {
+			c = new condition()
+			processes.insert(timeout, c); //inserisce in coda
+			c.wait();
+		}
+		if(activatedByTimeout == true) {
+			init++;
+			activatedByTimeout = false;
+			return true;
+		}
+		else {
+			activatedByTimeout = false;
+			return false;
+		}
+	}
+
+	public void entry tick(void) {
+		for(process : processes) {
+			process.first--;
+			if(process.first < 0) {
+				activatedByTimeout = true;
+				process.second.signal();
+				processes.remove(process); //ovunque sia nella struttura dati
+			}
+		}
+	}
+}