ProvaTeorica 2014.02.22 - Revision history

FedericoB: /* Soluzione di FedericoB */ Corretto nome di variabile nella spiegazione di una soluzione.

2017-09-10T12:49:48Z

Soluzione di FedericoB: Corretto nome di variabile nella spiegazione di una soluzione.

FedericoB: /* Soluzione di FedericoB */ Corretta soluzione a seguito di una segnalazione fatta da un collega

2017-07-16T18:30:09Z

Soluzione di FedericoB: Corretta soluzione a seguito di una segnalazione fatta da un collega

FedericoB: /* Esercizio c.2 */ Aggiunta soluzione

2017-06-12T14:12:57Z

Esercizio c.2: Aggiunta soluzione

FedericoB: Migliorata formattazione pagina

2017-06-12T13:04:31Z

Migliorata formattazione pagina

Diego.tului at 09:05, 18 September 2014

2014-09-18T09:05:35Z

Diego.tului at 14:11, 9 June 2014

2014-06-09T14:11:00Z

Diego.tului at 14:08, 9 June 2014

2014-06-09T14:08:57Z

Diego.tului at 14:07, 9 June 2014

2014-06-09T14:07:45Z

Diego.tului at 14:03, 9 June 2014

2014-06-09T14:03:15Z

Save at 16:29, 30 May 2014

2014-05-30T16:29:17Z

@@ Line 130: / Line 130: @@
 alpha assegna valori costanti quindi non è possibile utilizzarla per la test and set in quanto il suo risultato non può essere influenzato da parametri esterni.
-bravo(lock,vp) assegna a lock 4 e a y la radice del vecchio lock
+bravo(lock,vp) assegna a lock 4 e a vp la radice del vecchio lock
 Un possibile codice che utilizza bravo è il seguente:
 <pre>

@@ Line 141: / Line 141: @@
 		} while (vp==2)
 		//sezione critica
-		lock=0
+                vp=0
+		}
 </pre>
@@ Line 154: / Line 155: @@
 		} while (vp!=1)
 		//sezione critica
-		lock=1
+		vp=1
+		}
 </pre>

← Older revision		Revision as of 14:12, 12 June 2017
Line 126:		Line 126:

	Diego		Diego
		+
		+	===Soluzione di FedericoB===
		+	alpha assegna valori costanti quindi non è possibile utilizzarla per la test and set in quanto il suo risultato non può essere influenzato da parametri esterni.
		+
		+	bravo(lock,vp) assegna a lock 4 e a y la radice del vecchio lock
		+	Un possibile codice che utilizza bravo è il seguente:
		+	<pre>
		+	int lock=0
		+	process p
		+	int vp;
		+	while(1) {
		+	do {
		+	bravo(lock,vp)
		+	} while (vp==2)
		+	//sezione critica
		+	lock=0
		+	}
		+	</pre>
		+	charlie(lock,vp) assegna a lock 4 moltiplicato per la radice del vecchio lock e a vp la radice del vecchio lock
		+	<pre>
		+	int lock=1
		+	process p
		+	int vp;
		+	while(1) {
		+	do {
		+	charlie(lock,vp)
		+	} while (vp!=1)
		+	//sezione critica
		+	lock=1
		+	}
		+	</pre>
		+	Ho cambiato il valore iniziale del lock per evitare l'effetto assorbente dello zero.
		+	Inoltre ora quando il lock è impostato i processi in attesa avranno un vp completamente differente tra loro quindi ho dovuto utilizzare una diseguaglianza.
		+
		+	delta(z,t)
		+	<pre>
		+	zi ti zf tf
		+	comb1 0 0 0 0
		+	comb2 0 1 1 0
		+	comb3 1 0 1 1
		+	comb4 1 1 0 1
		+	</pre>
		+	Impossibile perchè nessuna delle combinazioni di input e utilizzabile.
		+	La combinazioni 1 e 3 non cambiano il lock e quindi non ci sarebbe mutua esclusione.
		+	Utilizzando le combinazioni 2 e 3 (quindi con vp inizializzato a 1) non ci sarebbe comunque mutua esclusione perchè
		+	se inizializziamo lock a 0 viene messo dalla combinazione 2 a 1 e vp=0, il primo processo ottiene la sezione critica.
		+	Un altro processo si troverebbe il lock impostato a 1 e vp=1 per inizializzazione locale.
		+	Verrebbe quindi utilizzata la combinazione 4 che però riporterebbe il lock a 0 e quindi un terzo processo potrebbe entrare in sezione critica.

	==Esercizio g.1==		==Esercizio g.1==

@@ Line 1: / Line 1: @@
 Testo: [http://www.cs.unibo.it/~renzo/so/compiti/2014.02.21.tot.pdf]
-Esercizio c.1
+==Esercizio c.1==
 <syntaxhighlight lang="C">
@@ Line 39: / Line 41: @@
 </syntaxhighlight>
-Esercizio c.1
+===Soluzione di Save===
- questa è la mia interpretazione
 <syntaxhighlight lang="C">
@@ Line 74: / Line 76: @@
+  }
+}
+</syntaxhighlight>
 save
-</syntaxhighlight>
+==Esercizio c.2==
-Esercizio c.2
+===Soluzione di Coci===
 alpha(x,y): <x=4, y=sqrt(x)>
@@ Line 87: / Line 89: @@
 bravo(x,y): <y=sqrt(x), x=4>
 xi yi xf yf
   0  4  0
@@ Line 92: / Line 95: @@
   0  4  1
   1  4  1
 il valore iniziale di x viene salvato in y, quindi va bene.
@@ Line 100: / Line 104: @@
 delta(z,t): <z=z xor t, t=z xor t>
+<pre>
 zi ti zf tf
   0  0  0
@@ Line 106: / Line 110: @@
   0  1  1
   1  0  1
+</pre>
 Il valore iniziale di z viene salvato in t, quindi va bene.
------------------------
+===Soluzione di Diego.tului===
     alpha: non funziona perché y non andrà mai a 0, quindi non entrerà mai in CS.
@@ Line 124: / Line 126: @@
 Diego
-Esercizio g.1
+==Esercizio g.1==
 Sia n=3 il numero di pagine mantenute in memoria
@@ Line 151: / Line 154: @@
 Alessandro
-Esercizio g.1
+===Soluzione di Diego.tului===
 Sia n=3 il numero di pagine mantenute in memoria
@@ Line 164: / Line 166: @@
      222221112221112221
       3333333333333333

← Older revision		Revision as of 09:05, 18 September 2014
Line 151:		Line 151:

	Alessandro		Alessandro
		+	------------------------------
		+
		+	Esercizio g.1
		+
		+	Sia n=3 il numero di pagine mantenute in memoria
		+
		+	la soluzione di Alessandro secondo noi presenta dei problemi, la integriamo:
		+
		+	a) 1234431432431432431
		+
		+	111444444444444444
		+	222221112221112221
		+	3333333333333333
		+
		+	Lorenzo

← Older revision		Revision as of 14:11, 9 June 2014
Line 120:		Line 120:
	sarà mutua esclusione.		sarà mutua esclusione.

−	delta: dipende dal valore iniziale di t, perché se all'inizio è 0, 0 xor 0 resta sempre 0.	+	delta: dipende dal valore iniziale di t, perché se all'inizio è 0, 0 xor 0 resta sempre 0, ergo come sopra.

@@ Line 117: / Line 117: @@
     bravo: funziona perché quando y va a 0 x rimane 4, e perciò finché x non ritorna 0 la CS è occupata.
-    charlie: dipende dal valore iniziale di x, perché se all'inizio x = 0 (y = 0, x = 4 * 0 = 0) quindi non ci sarà  mutua esclusione.
+    charlie: dipende dal valore iniziale di x, perché se all'inizio x = 0 (y = 0, x = 4 * 0 = 0) quindi non ci
     delta: dipende dal valore iniziale di t, perché se all'inizio è 0, 0 xor 0 resta sempre 0.

← Older revision		Revision as of 14:03, 9 June 2014
Line 108:		Line 108:

	Il valore iniziale di z viene salvato in t, quindi va bene.		Il valore iniziale di z viene salvato in t, quindi va bene.
		+
		+	-----------------------
		+
		+	La mia soluzione (prova)
		+
		+	alpha: non funziona perché y non andrà mai a 0, quindi non entrerà mai in CS.
		+
		+	bravo: funziona perché quando y va a 0 x rimane 4, e perciò finché x non ritorna 0 la CS è occupata.
		+
		+	charlie: NON funziona perché x e y saranno sempre 0 (se y = 0, x = 4 * 0 = 0) quindi non ci sarà la mutua esclusione.
		+
		+	delta: dipende dal valore iniziale di t, perché se all'inizio è 0, 0 xor 0 resta sempre 0.
		+
		+
		+	Diego
		+	-----------------------

	Esercizio g.1		Esercizio g.1