Prova teorica 2015.01.20 - Revision history

FedericoB: /* Soluzione di FedericoB */ Eliminati controlli e contatori inutili.

2017-06-14T06:51:17Z

Soluzione di FedericoB: Eliminati controlli e contatori inutili.

FedericoB: /* Soluzione di FedericoB */ Corretta soluzione precendente che era sbagliata, quella attuale si può migliorare.

2017-06-13T20:25:56Z

Soluzione di FedericoB: Corretta soluzione precendente che era sbagliata, quella attuale si può migliorare.

Save at 08:09, 23 May 2017

2017-05-23T08:09:13Z

FedericoB: /* Esercizio c.1 */

2017-05-09T12:51:37Z

Esercizio c.1

FedericoB: /* Esercizio c.2 */

2017-05-09T12:28:29Z

Esercizio c.2

FedericoB: Aggiunta soluzione all'esercizio 1 di un altro studente

2017-05-06T13:27:00Z

Aggiunta soluzione all'esercizio 1 di un altro studente

S.G: /* Esercizio c.1 */

2016-11-22T09:12:05Z

Esercizio c.1

S.G: /* Esercizio c.2 */

2016-11-22T08:23:30Z

Esercizio c.2

S.G: /* Esercizio g.2 */

2016-11-22T08:19:14Z

Esercizio g.2

S.G: /* Esercizio g.1 */

2016-11-22T08:17:42Z

Esercizio g.1

@@ Line 137: / Line 137: @@
 </source>
 ===Soluzione di FedericoB===
-Pseudocodice simil python. Forse soluzione troppo lunga, si può migliorare.
+Essendo l'accesso al monitor in mutua esclusione non c'è da considerare il caso in cui ci siano più lettori in concorrenza. <br>
 <source lang="Python">
-monitor lwlrbb
+monitor lwlrbb:
 	Queue[generic_type] buffer
-	int numWriter, numReader, waitingReader, waitingWriters
+	int  waitingReaders, waitingWriters
 	condition ok2write, ok2read
 	int max;
-	lwlrbb (int max)
+	lwlrbb (int max):
 		self.max = max
 		buffer = new List(max)
-		numWriter = 0
+		waitingReaders = 0
-		numReader = 0
+		waitingWriters = 0
-		waitingReader = 0
+		exitNull = False
 	@entry
-	void write(generic_type val)
+	void write(generic_type val):
-		if (buffer.size()>=MAX) and (waitingWriters>Max)
+		if (buffer.size()>=MAX) :
-				#wakeup for discard
+				if (waitingWriters>Max):
-				ok2write.signal()
+					buffer.dequeue() #discard element
-		if (numWriter>0 or numReader>0) or (buffer.size>=MAX)
+					ok2write.signal()
 			waitingWriters+=1
 			ok2write.wait()
 			waitingWriters-=1
 		buffer.enqueue(val)
-		numWriter-=1
+		if (waitingReaders>0) ok2read.signal()
 		else if (waitingWriters>0) ok2write.signal()
 	@entry
-	generic_type read()
+	generic_type read():
-		if (buffer.isEmpty()
+		if (buffer.isEmpty():
-			if (waitingReader>Max):
+			if (waitingReaders>Max):
-				#do not decrement waitingReader
+				exitNull = True #set flag to make the woke up reader return null
 				ok2read.signal()
-			else
+			waitingReaders++
 			ok2read.wait()
-			waitingReader-=1
+			waitingReaders--
-			if (waitingReader >= max)
+			if (exitNull):
-				ok2read.signal()
+				exitNull = False
 				return null
-		else
+		element = buffer.dequeue()
-			numReader+=1
+		if (waitingWriters>0) ok2write.signal()
-			element = buffer.dequeue()
+		else if (waitingReaders>0) ok2read.signal()
 </source>

@@ Line 137: / Line 137: @@
 </source>
 ===Soluzione di FedericoB===
-Pseudocodice simil python
+Pseudocodice simil python. Forse soluzione troppo lunga, si può migliorare.
 <source lang="Python">
 monitor lwlrbb
-	queue buf
-	contion ok2read, ok2write; int wr=0; int ww=0
+	Queue[generic_type] buffer
+	int numWriter, numReader, waitingReader, waitingWriters
-proc entry write(val)
+	condition ok2write, ok2read
-	if (buf.len()) >= BUFSIZE):
+	int max;
-		if (ww>=max):
-			ok2write.signal()
+	lwlrbb (int max)
-		else:
+		self.max = max
-			w++
+		buffer = new List(max)
 			ok2write.wait()
-			w--
+			waitingWriters-=1
-	if (buf.len() >= BUFSIZE):
+			if (waitingReader >=Max)
-		buf.deque()
+				buffer.dequeue()
-		buf.enqueue(val)
+				ok2write.signal()
-		ok2read.signal()
+				return;
+		numWriter+=1
-proc entry read()
+		buffer.enqueue(val)
-	if (buf.len()==0):
+		numWriter-=1
-		if (wr>=max):
+		ok2write.signal()
-			//il primo lettore deve usire
+		if (waitingReader>0) ok2read.signal()
-			ok2read.signal()
+		else if (waitingWriters>0) ok2write.signal()
-			wr++
 			ok2read.wait()
-			wr--
+			waitingReader-=1
-	if (buf.len()>0):
+			if (waitingReader >= max)
-		retval = buf.dequeue()
+				ok2read.signal()
-		ok2write.signal()
+				return null
 </source>
 ===Soluzione di sav, correggetemi se sbaglio ===
 <source lang="Python">

← Older revision		Revision as of 08:09, 23 May 2017
Line 169:		Line 169:

	</source>		</source>
		+	===Soluzione di sav, correggetemi se sbaglio ===
		+	<source lang="Python">
		+	monitor lwlbb
		+	{
		+	buffer buf, wr //buf = buffer di elementi e wr buffer di lettori
		+	condition oktoread, oktowrite
		+
		+	Procedure entry read {
		+
		+	if ( wr.len() < MAXLETTORI)
		+	if (buf.len() == 0)
		+	wr. enqueue(lettore)
		+	oktoread.wait(lettore)
		+	wr.dequeue(lettore)
		+	buf.dequeue()
		+	oktoread.signal()
		+	wr.dequeue()
		+	wr.enqueue(lettore)
		+
		+	}
		+
		+	procedure entry write (val) { //lo scrittore non resterà mai in attesa perché se non c'è spazio nel buffer toglie
		+	//il primo elemento inserito e mette il suo nuovo e sblocca un eventuale lettore in attesa
		+
		+	if (buf.len()< MAXBUFFER)
		+	buf.enqueue(val)
		+	oktoread.signal()
		+	buf.dequeue()
		+	buf.enqueue(val)
		+	oktoread.signal()
		+	}
		+	}
		+
		+
		+	</source>
		+

	== Esercizio c.2 ==		== Esercizio c.2 ==

@@ Line 136: / Line 136: @@
+}
 </source>
 == Esercizio c.2 ==
 ===Soluzione di S.G===

@@ Line 137: / Line 137: @@
 </source>
 == Esercizio c.2 ==
+===Soluzione di S.G===
 a) Si consideri la funzione atomica dualshift(a,b) che opera su due operandi di tipo byte passati per indirizzo. L'operazione fa lo shift a
 destra dei due operandi. Il bit piu' significativo di a viene posto a zero, il bit piu' significativo di b diviene quello che all'atto della
@@ Line 217: / Line 217: @@
 </syntaxhighlight>
 ----
 == Esercizio g.1 ==

@@ Line 2: / Line 2: @@
 == Esercizio c.1 ==
+===Soluzione di S.G===
 <syntaxhighlight lang="C">
 /*
@@ Line 78: / Line 78: @@
 Ho implementato la coda. [[User:S.G|S.G]] ([[User talk:S.G|talk]]) 10:12, 22 November 2016 (CET)
 ----
 == Esercizio c.2 ==

@@ Line 19: / Line 19: @@
 monitor lwlrbb{
 	generic_type bb[];
-	int i, nw, nr;
+	int count, rear, front, nw, nr;
 	bool exitNull;
 	conditions lw, lr;
@@ Line 26: / Line 26: @@
 		bb = new generic_type[MAX];
 		exitNull = FALSE;
-		i = nw = nr = 0;
+		rear = count = front = nw = nr = 0;
+	}
 	procedure entry void write(generic_type val){
-		if(i == MAX){					// Il buffer è completamente pieno
+		if(count == MAX){				// Il buffer è completamente pieno
 			if(nw == MAX){				// ci sono già MAX scrittori che attendono di scrivere
-								// spostamento a sinistra di tutti gli elementi, in modo da perdere
+				rear = (rear + 1) % MAX;	// Salto l'elemento da leggere da più tempo
-				for(j = 0; j<i; j++)		// il valore da più tempo nel buffer
+				count--;
-					bb[j] = bb[j+1];
+				lw.signal();			// il primo processo in attesa di scrivere puo' sbloccarsi.
+			}
 			nw++;
@@ Line 42: / Line 40: @@
 			nw--;
+		}
-							// Il buffer non è pieno
+		bb[front] = val;				// Il buffer non è pieno, scrivo
-		bb[i] = val;
+		count++;
-		i++;
+		front = (front + 1) % MAX;
 		lr.signal();
+	}
@@ Line 50: / Line 48: @@
 	procedure entry generic_type read(void){
 		generic_type retval;
-		if(i == 0){				// Il buffer è vuoto
+		if(count == 0){				// Il buffer è vuoto
 			if(nr == MAX){			// ci sono gia MAX lettori in attesa
 				exitNull = TRUE;	// quindi riattivio il lettore che e' in attesa da piu' tempo, restituendo NULL
@@ Line 63: / Line 61: @@
 				return NULL;
+			}
-−
+		}
-						// Il buffer non è vuoto
+		count--;				// Il buffer non è vuoto, leggo
-		i--;
+		retval = bb[rear];
-		retval = bb[i];
+		rear = (rear + 1) % MAX;
-		lw.signal();			// Riattivo uno scrittore in coda
+		lw.signal();
+	}
+}
 </syntaxhighlight>
@@ Line 77: / Line 75: @@
 '''&egrave; uno stack! bounded buffer deve implementare una coda.''' [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 19:29, 21 November 2016 (CET)
 ----

← Older revision		Revision as of 08:23, 22 November 2016
Line 144:		Line 144:

	'''a è errato, pensateci meglio. Per B la variabile a va indicata come locale al processo P (generico) che deve avere un loop infinito.''' [[User:Renzo\|Renzo]] ([[User talk:Renzo\|talk]]) 19:25, 21 November 2016 (CET)		'''a è errato, pensateci meglio. Per B la variabile a va indicata come locale al processo P (generico) che deve avere un loop infinito.''' [[User:Renzo\|Renzo]] ([[User talk:Renzo\|talk]]) 19:25, 21 November 2016 (CET)
		+
		+	Quindi una soluzione del genere potrebbe andar bene? [[User:S.G\|S.G]] ([[User talk:S.G\|talk]]) 09:23, 22 November 2016 (CET)
		+	<syntaxhighlight lang="C">
		+	b = 0;
		+
		+	Process P {
		+	do{
		+	a = 1;
		+	dualshift(a, b);
		+	} while(b != 128);
		+	//critical section
		+	b = 0;
		+	// non-critical section
		+	}
		+	</syntaxhighlight>
	----		----

← Older revision		Revision as of 08:19, 22 November 2016
Line 241:		Line 241:

	'''Cosa significa proporre a novembre le risposte a quesiti relativi a argomenti che spieghero' nel secondo semestre?'''[[User:Renzo\|Renzo]] ([[User talk:Renzo\|talk]]) 19:21, 21 November 2016 (CET)		'''Cosa significa proporre a novembre le risposte a quesiti relativi a argomenti che spieghero' nel secondo semestre?'''[[User:Renzo\|Renzo]] ([[User talk:Renzo\|talk]]) 19:21, 21 November 2016 (CET)
		+
		+	Mi scuso per l'inconveniente, avendo seguito il corso di SO 2015/2016 ho pensato di creare una sezione PROVE SVOLTE che fosse ben visibile a tutti i corsi sia per gli anni precedenti sia per gli anni successi. [[User:S.G\|S.G]] ([[User talk:S.G\|talk]]) 09:19, 22 November 2016 (CET)

← Older revision		Revision as of 08:17, 22 November 2016
Line 196:		Line 196:

	'''Cosa significa proporre a novembre le risposte a quesiti relativi a argomenti che spieghero' a marzo 2017?'''[[User:Renzo\|Renzo]] ([[User talk:Renzo\|talk]]) 19:20, 21 November 2016 (CET)		'''Cosa significa proporre a novembre le risposte a quesiti relativi a argomenti che spieghero' a marzo 2017?'''[[User:Renzo\|Renzo]] ([[User talk:Renzo\|talk]]) 19:20, 21 November 2016 (CET)
		+
		+	Mi scuso per l'inconveniente, avendo seguito il corso di SO 2015/2016 ho pensato di creare una sezione PROVE SVOLTE che fosse ben visibile a tutti i corsi sia per gli anni precedenti sia per gli anni successi
		+	[[User:S.G\|S.G]] ([[User talk:S.G\|talk]]) 09:17, 22 November 2016 (CET)
	----		----