ProvaTeorica 2013.05.30 - Revision history

Coci at 16:00, 19 May 2014

2014-05-19T16:00:12Z

Mrta at 15:29, 19 May 2014

2014-05-19T15:29:40Z

Stanislao at 15:09, 12 May 2014

2014-05-12T15:09:58Z

Stanislao at 13:39, 12 May 2014

2014-05-12T13:39:05Z

Stanislao at 15:38, 4 May 2014

2014-05-04T15:38:10Z

Stanislao at 13:58, 4 May 2014

2014-05-04T13:58:04Z

Stanislao at 17:12, 3 May 2014

2014-05-03T17:12:00Z

Stanislao at 16:09, 2 May 2014

2014-05-02T16:09:12Z

Stanislao at 16:05, 2 May 2014

2014-05-02T16:05:04Z

Stanislao at 16:03, 2 May 2014

2014-05-02T16:03:18Z

← Older revision		Revision as of 16:00, 19 May 2014
Line 1:		Line 1:
	<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.05.30.tot.pdf Testo del compito]</h1>		<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.05.30.tot.pdf Testo del compito]</h1>
		+	<h2> Esercizio c.1</h2>
		+	<syntaxhighlight lang="C">
		+	monitor eventp {
		+	typedef struct EP {
		+	unsigned int value;
		+	condition okNotNull;
		+	condition okToaAdd;
		+	intqueue q;
		+	} EP;
		+	procedure entry EP* create (unsigned value){
		+	if (d.value+value > MAXINT \|\| !d.queue.isEmpty()) {
		+	d.q.enqueue(value);
		+	d.okToAdd.wait();
		+	d.q.dequeue();
		+	}
		+	d.value = d.value + value;
		+	if (d.q.top() + value <= d.value.size()) //se il suo valore proposto non causa l’overflow del counter, sblocco lo scrittore successivo
		+	d.okToAdd.signal();
		+	else
		+	d.okNotNull.signal();
		+	}

		+	procedure entry unsigned int read (EP* ep){
		+	if (!ep.value)
		+	ep.okNotNull.wait();
		+	unsigned int toReturn = ep.value;
		+	ep.value = 0;
		+	ep.okToAdd.signal();
		+	return toReturn;
		+	}
		+
		+	procedure entry close(EP * ep){
		+	free(ep);
		+	}
		+
		+	}
		+	</syntaxhighlight>
	<h2> Esercizio g.1</h2>		<h2> Esercizio g.1</h2>

← Older revision		Revision as of 15:29, 19 May 2014
Line 8:		Line 8:
	<h2> Esercizio g.2 </h2>		<h2> Esercizio g.2 </h2>
	[[File:Holt.png]]		[[File:Holt.png]]
		+
		+
		+	<syntaxhighlight lang="C">
		+	monitor eventp
		+	{
		+	typedef struct EP
		+	{
		+	unsigned int value;
		+	condition okNotNull;
		+	condition okToAdd;
		+	intqueue q;
		+	}
		+	}
		+
		+	procedure entry EP* create(unsigned value)
		+	{
		+	EP *ep = new EP(value);
		+	eps.enqueu(ep);
		+	return ep;
		+	}
		+
		+	procedure entry write(EP *d,unsigned value)
		+	{
		+	if(d.value+value > d.value.size()\|\| !d.q.empty()) {
		+	d.q.enqueue(value);
		+	d.okToAdd.wait();
		+	d.q.dequeue();
		+	}
		+	d.value = d.value + value;
		+	if (d.q.top()+value <= d.value.size())
		+	d.okToAdd.signal();
		+	else
		+	d.okNotNull.signal();
		+	}
		+
		+	// MAXINT - currentvalue < value
		+	procedure entry unsigned int read(EP *ep)
		+	{
		+	if(!ep.value)
		+	ep.okNotNull.wait();
		+	unsigned int toReturn = ep.value;
		+	ep.value = 0;
		+	ep.okToAdd.signal();
		+	return toReturn;
		+	}
		+	<syntaxhighlight>

← Older revision		Revision as of 15:09, 12 May 2014
Line 1:		Line 1:
	<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.05.30.tot.pdf Testo del compito]</h1>		<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.05.30.tot.pdf Testo del compito]</h1>
−
−	~~<h2>Esercizio c.1</h2>~~
−
−	~~<syntaxhighlight lang="C">~~
−
−	~~/* Esercizio c.1: scrivere un monitor eventp che realizzi un servizio di sincronizzazione cosi' definito:~~
−	~~procedure entry EP *create(unsigned value): crea un nuovo descrittore. Ogni descrittore ha un contatore associato.~~
−
−	~~Value e' il valore iniziale del contatore.~~
−
−	~~procedure entry void write(EP *d, unsigned value): se il contatore ha un valore tale che se si sommasse value causerebbe overflow,~~
−	~~sospende il processo chiamante. In ogni caso~~
−	~~(se la somma e' possibile senza overflow o quando la somma e' possibile senza overflow)~~
−	~~somma value al valore del contatore.~~
−
−	~~procedure entry unsigned read(EP *d): se il contatore ha valore nullo sospende il processo chiamante fino a che il contatore diventi~~
−	~~non nullo.~~
−	~~In ogni caso restituisce il valore del contatore e riporta il contatore al valore zero.~~
−
−	~~procedure entry void close(EP *d): termina le operazioni del descrittore d e cancella il descrittore.~~
−	*/
−
−
−	~~monitor eventp{~~
−
−	~~#define OVERFLOW 999;~~
−
−	~~condition okToWrite, okToRead;~~
−	~~unsigned int oldValue;~~
−
−	~~struct EP {~~
−	~~unsigned int count;~~
−	~~} d;~~
−
−
−
−	~~procedure entry EP *create(value){~~
−
−
−	~~d.count = value;~~
−
−	~~return d;~~
−
−	}
−
−
−
−	~~procedure entry void write(EP *d, unsigned value){~~
−
−	~~if(d.count+value > OVERFLOW)~~
−
−	~~okToWrite.wait();~~
−	~~d.count= d.count + value;~~
−	~~okToRead.signal();~~
−	~~else~~
−	~~d.count = d.count + value;~~
−
−	}
−
−
−
−	~~procedure entry unsigned read (EP *d){~~
−
−	~~if(d.count == NULL)~~
−
−	~~okToRead.wait();~~
−	~~oldValue = d.count;~~
−	~~d.count = 0;~~
−	~~okToWrite.signal();~~
−	~~return oldValue;~~
−	~~else~~
−	~~oldValue=d.count;~~
−	~~d.count=0;~~
−	~~return oldValue;~~
−	}
−
−	~~procedure entry void close(EP* d){~~
−
−	~~close(d);~~
−	~~delete(d);~~
−	}
−
−	~~</syntaxhighlight>~~
−
−	~~<h2> Esercizio c.2 </h2>~~
−

	<h2> Esercizio g.1</h2>		<h2> Esercizio g.1</h2>

← Older revision		Revision as of 13:39, 12 May 2014
Line 86:		Line 86:
	<h2> Esercizio c.2 </h2>		<h2> Esercizio c.2 </h2>

−	~~<syntaxhighlight lang="C">~~

−	~~/* I semafori v2p hanno come invariante 2*np <= nv + Init, dove np e' il numero di operazioni P completate,~~
−	~~nv e' il numero delle operazioni V completate e Init e' il valore iniziale~~
−	~~(cioe' occorrono 2 operazioni V per sbloccare un processo che ha fatto P).~~
−	~~I semafori v2p hanno lo stesso potere espressivo dei semafori generali o no?~~
−	~~Produrre una dimostrazione della tesi sostenuta.*/~~
−
−	~~/* I semafori v2p non hanno lo stesso potere espressivo di quelli generali~~
−
−	~~DIMOSTRAZIONE: prendo due processi P e Q in questo modo qui: */~~
−
−	~~process P{~~
−
−	~~while (true){~~
−
−	~~P();~~
−
−	~~printf(“sono p”);~~
−
−	}
−	}
−
−	~~process Q{~~
−
−	~~while (true){~~
−
−	~~printf(“sono q”);~~
−
−	~~V();~~
−
−	}
−	}
−
−	~~/* inizializzo entrambi i semafori a 2 */~~
−
−	~~semaforo v2p(2)~~
−	~~semaforo generale(2)~~
−
−	~~PPPQQQ // sequenza di avvicendamento dei processi~~
−
−
−	~~v2p(2) generale(2) // v2p VS generale~~
−
−	~~sono p sono p~~
−	~~sono p sono p~~
−	~~sono q sono q~~
−	~~sono q sono p~~
−	~~sono p sono q~~
−	~~sono q sono q~~
−
−	~~/* con la stessa sequenza di avvicendamento dei processi possiamo notare che l'output generato da entrambi~~
−	~~i processi è diverso e quindi i semafori v2p non hanno lo stesso potere espressivo dei semafori generali */~~
−
−	~~</syntaxhighlight>~~
	<h2> Esercizio g.1</h2>		<h2> Esercizio g.1</h2>

← Older revision		Revision as of 15:38, 4 May 2014
Line 147:		Line 147:

	<h2> Esercizio g.2 </h2>		<h2> Esercizio g.2 </h2>
−	[[[File:Holt.png]]	+	[[File:Holt.png]]

← Older revision		Revision as of 13:58, 4 May 2014
Line 145:		Line 145:
	<p> <b>PUNTO A:</b> (7+256+(256^2)+(256^3))*1kb =16.843.015kb quindi approssimativamente 16MB</p>		<p> <b>PUNTO A:</b> (7+256+(256^2)+(256^3))*1kb =16.843.015kb quindi approssimativamente 16MB</p>
	<p> <b> PUNTO B:</B> blocco indiretto triplo -> primo livello di idirizzamento 256 esimo blocco -> secondo livello di indirizzamento 256 esimo blocco -> terzo livello di indirizzamento al blocco 100000. Qundi in totale 4 blocchi </p>		<p> <b> PUNTO B:</B> blocco indiretto triplo -> primo livello di idirizzamento 256 esimo blocco -> secondo livello di indirizzamento 256 esimo blocco -> terzo livello di indirizzamento al blocco 100000. Qundi in totale 4 blocchi </p>
		+
		+	<h2> Esercizio g.2 </h2>
		+	[[[File:Holt.png]]

← Older revision		Revision as of 17:12, 3 May 2014
Line 141:		Line 141:

	</syntaxhighlight>		</syntaxhighlight>
		+	<h2> Esercizio g.1</h2>
		+
		+	<p> <b>PUNTO A:</b> (7+256+(256^2)+(256^3))*1kb =16.843.015kb quindi approssimativamente 16MB</p>
		+	<p> <b> PUNTO B:</B> blocco indiretto triplo -> primo livello di idirizzamento 256 esimo blocco -> secondo livello di indirizzamento 256 esimo blocco -> terzo livello di indirizzamento al blocco 100000. Qundi in totale 4 blocchi </p>

@@ Line 11: / Line 11: @@
 procedure entry void write(EP *d, unsigned value): se il contatore ha un valore tale che se si sommasse value causerebbe overflow,
-sospende il processo chiamante. In ogni caso (se la somma e' possibile senza overflow o quando la somma e' possibile senza overflow)
+sospende il processo chiamante. In ogni caso
 somma value al valore del contatore.
-procedure entry unsigned read(EP *d): se il contatore ha valore nullo sospende il processo chiamante fino a che il contatore diventi non nullo.
+procedure entry unsigned read(EP *d): se il contatore ha valore nullo sospende il processo chiamante fino a che il contatore diventi
 In ogni caso restituisce il valore del contatore e riporta il contatore al valore zero.

@@ Line 87: / Line 87: @@
 /* I semafori v2p hanno come invariante 2*np <= nv + Init, dove np e' il numero di operazioni P completate,
-nv e' il numero delle operazioni V completate e Init e' il valore iniziale (cioe' occorrono 2 operazioni V per sbloccare un processo che ha fatto P).
+nv e' il numero delle operazioni V completate e Init e' il valore iniziale
 I semafori v2p hanno lo stesso potere espressivo dei semafori generali o no?
 Produrre una dimostrazione della tesi sostenuta.*/
@@ Line 125: / Line 126: @@
-v2p(2)	generale(2)  // v2p VS generale
+v2p(2)	       generale(2)  // v2p VS generale
-sono p	sono p
+sono p	       sono p
-sono p	sono p
+sono p	       sono p
-sono q	sono q
+sono q	       sono q
-sono q	sono p
+sono q	       sono p
-sono p	sono q
+sono p	       sono q
-sono q	sono q
+sono q	       sono q
-/* con la stessa sequenza di avvicendamento dei processi possiamo notare che l'output generato da entrambi i processi è diverso e quindi i semafori v2p non hanno lo stesso potere espressivo dei semafori generali
+/* con la stessa sequenza di avvicendamento dei processi possiamo notare che l'output generato da entrambi
 </syntaxhighlight>

@@ Line 79: / Line 79: @@
 			delete(d);
+}
 </syntaxhighlight>