Sistemi Operativi - User contributions [en]

ProvaTeorica 2013.02.15

2014-05-13T14:31:46Z

Stanislao:

<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.02.15.tot.pdf Testo del compito]</h1>

Esercizio c.1

<syntaxhighlight lang="C">
/*
Esercizio c.1: (a) Scrivere un monitor dualwriter che realizzi un doppio buffer limitato (ogni buffer ha ampiezza
BUFSIZE) che consenta a uno scrittore di scrivere contemporaneamente due elementi che andranno rispettivamente
nel primo e nel secondo buffer. Le letture :
procedure entry void write(type1 e1, type2 e2);
procedure entry type1 read1();
procedure entry type2 read2();
La funzione write deve attendere che ci sia spazio in entrambi i buffer.
La funzione read attende che vi sia almeno un elemento nel buffer indicato
*/
monitor dualwriter
{
type1* buffer1;
type2* buffer2;
condition oktowrite,oktoread1, oktoread2
procedure entry void write (type1 e1, type2 e2)
{
if (sizeof(type1)>=BUFSIZE || sizeof(type2)>=BUFSIZE)
oktowrite.wait();
buffer1.push(e1);
buffer2.push(e2);
oktoread1.signal();
oktoread2.signal();
}

procedure entry type1 read1()
{
if (sizeof(buffer1)==0)
oktoread1.wait();
buffer1.pop();
if (sizeof(buffer2)<BUFSIZE)
oktowrite.signal();
}

procedure entry type2 read2()
{
if (sizeof(buffer2)==0)
oktoread2.wait();
buffer2.pop();
if (sizeof(buffer1)<BUFSIZE)
oktowrite.signal();
}
}
</syntaxhighlight>
-stefano92

----

<syntaxhighlight lang="C">
monitor dualwriter{
queue buffer1;
queue buffer2;
condition oktowrite;
condition oktoread1;
condition oktoread2;

procedure entry void write(type1 e1, type2 e2){
if((buffer1.len() == BUFSIZE) || (buffer2.len() == BUFSIZE)) /*se uno dei due buffer è pieno non puoi inserire*/
oktowrite.wait();

buffer1.enqueue(e1);
buffer2.enqueue(e2);

oktoread1.signal();
oktoread2.signal();
}

procedure entry type1 read1(){
if(buffer1.len() == 0) /*buffer vuoto*/
oktoread1.wait();

buffer1.dequeue;
oktowrite.signal();
}

procedure entry type2 read2(){
if(buffer2.len() == 0) /*buffer vuoto*/
oktoread2.wait();

buffer2.dequeue;
oktowrite.signal();
}
}
</syntaxhighlight>
Giulia
<h2> Esercizio c.2 </h2>
<syntaxhighlight lang="C">

// foo(x,y) <x=2+y , y=2+x>

int g = 0;

csenter:

do
int l;
foo(l, g);
while(l!=2)

csexit:

g = 0;

</syntaxhighlight>

<syntaxhighlight lang="C">

// bar (z,t) <z= z xor t, t= t xor z, z = z xor t>

z t z t z
0 0 0 0 0
0 1 1 0 1
1 0 1 1 0
1 1 0 1 1

void Swap(bool z, bool t){
bool tmp;
z=t;
t=tmp;
}
</syntaxhighlight>
<h2> Esercizio g.1 </h2>
[[File:RoundRobin2cpu.png]]

ProvaTeorica 2013.02.15

2014-05-13T14:30:58Z

Stanislao:

<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.02.15.tot.pdf Testo del compito]</h1>

Esercizio c.1

<syntaxhighlight lang="C">
/*
Esercizio c.1: (a) Scrivere un monitor dualwriter che realizzi un doppio buffer limitato (ogni buffer ha ampiezza
BUFSIZE) che consenta a uno scrittore di scrivere contemporaneamente due elementi che andranno rispettivamente
nel primo e nel secondo buffer. Le letture :
procedure entry void write(type1 e1, type2 e2);
procedure entry type1 read1();
procedure entry type2 read2();
La funzione write deve attendere che ci sia spazio in entrambi i buffer.
La funzione read attende che vi sia almeno un elemento nel buffer indicato
*/
monitor dualwriter
{
type1* buffer1;
type2* buffer2;
condition oktowrite,oktoread1, oktoread2
procedure entry void write (type1 e1, type2 e2)
{
if (sizeof(type1)>=BUFSIZE || sizeof(type2)>=BUFSIZE)
oktowrite.wait();
buffer1.push(e1);
buffer2.push(e2);
oktoread1.signal();
oktoread2.signal();
}

procedure entry type1 read1()
{
if (sizeof(buffer1)==0)
oktoread1.wait();
buffer1.pop();
if (sizeof(buffer2)<BUFSIZE)
oktowrite.signal();
}

procedure entry type2 read2()
{
if (sizeof(buffer2)==0)
oktoread2.wait();
buffer2.pop();
if (sizeof(buffer1)<BUFSIZE)
oktowrite.signal();
}
}
</syntaxhighlight>
-stefano92

----

<syntaxhighlight lang="C">
monitor dualwriter{
queue buffer1;
queue buffer2;
condition oktowrite;
condition oktoread1;
condition oktoread2;

procedure entry void write(type1 e1, type2 e2){
if((buffer1.len() == BUFSIZE) || (buffer2.len() == BUFSIZE)) /*se uno dei due buffer è pieno non puoi inserire*/
oktowrite.wait();

buffer1.enqueue(e1);
buffer2.enqueue(e2);

oktoread1.signal();
oktoread2.signal();
}

procedure entry type1 read1(){
if(buffer1.len() == 0) /*buffer vuoto*/
oktoread1.wait();

buffer1.dequeue;
oktowrite.signal();
}

procedure entry type2 read2(){
if(buffer2.len() == 0) /*buffer vuoto*/
oktoread2.wait();

buffer2.dequeue;
oktowrite.signal();
}
}
</syntaxhighlight>
Giulia
<h2> Esercizio c.2 </h2>
<syntaxhighlight lang="C">

// foo(x,y) <x=2+y , y=2+x>

int g = 0;

csenter:

do
int l;
foo(l, g);
while(l!=2)

csexit:

g = 0;

</syntaxhighlight>

<syntaxhighlight lang="C">

// bar (z,t) <z= z xor t, t= t xor z, z = z xor t>

z t z t z
0 0 0 0 0
0 1 1 0 1
1 0 1 1 0
1 1 0 1 1

void Swap(boolean z, boolean t){
boolean tmp;
z=t;
t=tmp;
}
</syntaxhighlight>
<h2> Esercizio g.1 </h2>
[[File:RoundRobin2cpu.png]]

ProvaTeorica 2013.02.15

2014-05-13T14:30:18Z

Stanislao:

<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.02.15.tot.pdf Testo del compito]</h1>

Esercizio c.1

<syntaxhighlight lang="C">
/*
Esercizio c.1: (a) Scrivere un monitor dualwriter che realizzi un doppio buffer limitato (ogni buffer ha ampiezza
BUFSIZE) che consenta a uno scrittore di scrivere contemporaneamente due elementi che andranno rispettivamente
nel primo e nel secondo buffer. Le letture :
procedure entry void write(type1 e1, type2 e2);
procedure entry type1 read1();
procedure entry type2 read2();
La funzione write deve attendere che ci sia spazio in entrambi i buffer.
La funzione read attende che vi sia almeno un elemento nel buffer indicato
*/
monitor dualwriter
{
type1* buffer1;
type2* buffer2;
condition oktowrite,oktoread1, oktoread2
procedure entry void write (type1 e1, type2 e2)
{
if (sizeof(type1)>=BUFSIZE || sizeof(type2)>=BUFSIZE)
oktowrite.wait();
buffer1.push(e1);
buffer2.push(e2);
oktoread1.signal();
oktoread2.signal();
}

procedure entry type1 read1()
{
if (sizeof(buffer1)==0)
oktoread1.wait();
buffer1.pop();
if (sizeof(buffer2)<BUFSIZE)
oktowrite.signal();
}

procedure entry type2 read2()
{
if (sizeof(buffer2)==0)
oktoread2.wait();
buffer2.pop();
if (sizeof(buffer1)<BUFSIZE)
oktowrite.signal();
}
}
</syntaxhighlight>
-stefano92

----

<syntaxhighlight lang="C">
monitor dualwriter{
queue buffer1;
queue buffer2;
condition oktowrite;
condition oktoread1;
condition oktoread2;

procedure entry void write(type1 e1, type2 e2){
if((buffer1.len() == BUFSIZE) || (buffer2.len() == BUFSIZE)) /*se uno dei due buffer è pieno non puoi inserire*/
oktowrite.wait();

buffer1.enqueue(e1);
buffer2.enqueue(e2);

oktoread1.signal();
oktoread2.signal();
}

procedure entry type1 read1(){
if(buffer1.len() == 0) /*buffer vuoto*/
oktoread1.wait();

buffer1.dequeue;
oktowrite.signal();
}

procedure entry type2 read2(){
if(buffer2.len() == 0) /*buffer vuoto*/
oktoread2.wait();

buffer2.dequeue;
oktowrite.signal();
}
}
</syntaxhighlight>
Giulia
<h2> Esercizio c.2 </h2>
<syntaxhighlight lang="C">

// foo(x,y) <x=2+y , y=2+x>

int g = 0;

csenter:

do
int l;
foo(l, g);
while(l!=2)

csexit:

g = 0;

</syntaxhighlight>

<syntaxhighlight lang="C">

// bar (z,t) <z= z xor t, t= t xor z, z = z xor t>

z t z t z
0 0 0 0 0
0 1 1 0 1
1 0 1 1 0
1 1 0 1 1

void Swap(boolean z, boolean t){
boolean tmp;
z=t;
t=tmp;
}
</syntaxhighlight>
<h2> Esercizio g.1 </h2>
[[File:RoundRobin2cpu.png]]

ProvaTeorica 2013.02.15

2014-05-13T14:23:56Z

Stanislao:

<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.02.15.tot.pdf Testo del compito]</h1>

Esercizio c.1

<syntaxhighlight lang="C">
/*
Esercizio c.1: (a) Scrivere un monitor dualwriter che realizzi un doppio buffer limitato (ogni buffer ha ampiezza
BUFSIZE) che consenta a uno scrittore di scrivere contemporaneamente due elementi che andranno rispettivamente
nel primo e nel secondo buffer. Le letture :
procedure entry void write(type1 e1, type2 e2);
procedure entry type1 read1();
procedure entry type2 read2();
La funzione write deve attendere che ci sia spazio in entrambi i buffer.
La funzione read attende che vi sia almeno un elemento nel buffer indicato
*/
monitor dualwriter
{
type1* buffer1;
type2* buffer2;
condition oktowrite,oktoread1, oktoread2
procedure entry void write (type1 e1, type2 e2)
{
if (sizeof(type1)>=BUFSIZE || sizeof(type2)>=BUFSIZE)
oktowrite.wait();
buffer1.push(e1);
buffer2.push(e2);
oktoread1.signal();
oktoread2.signal();
}

procedure entry type1 read1()
{
if (sizeof(buffer1)==0)
oktoread1.wait();
buffer1.pop();
if (sizeof(buffer2)<BUFSIZE)
oktowrite.signal();
}

procedure entry type2 read2()
{
if (sizeof(buffer2)==0)
oktoread2.wait();
buffer2.pop();
if (sizeof(buffer1)<BUFSIZE)
oktowrite.signal();
}
}
</syntaxhighlight>
-stefano92

----

<syntaxhighlight lang="C">
monitor dualwriter{
queue buffer1;
queue buffer2;
condition oktowrite;
condition oktoread1;
condition oktoread2;

procedure entry void write(type1 e1, type2 e2){
if((buffer1.len() == BUFSIZE) || (buffer2.len() == BUFSIZE)) /*se uno dei due buffer è pieno non puoi inserire*/
oktowrite.wait();

buffer1.enqueue(e1);
buffer2.enqueue(e2);

oktoread1.signal();
oktoread2.signal();
}

procedure entry type1 read1(){
if(buffer1.len() == 0) /*buffer vuoto*/
oktoread1.wait();

buffer1.dequeue;
oktowrite.signal();
}

procedure entry type2 read2(){
if(buffer2.len() == 0) /*buffer vuoto*/
oktoread2.wait();

buffer2.dequeue;
oktowrite.signal();
}
}
</syntaxhighlight>
Giulia
<h2> Esercizio c.2 </h2>
<syntaxhighlight lang="C">

// foo(x,y) <x=2+y , y=2+x>

int g = 0;

csenter:

do
int l;
foo(l, g);
while(l!=2)

csexit:

g = 0;

</syntaxhighlight>

<h2> Esercizio g.1 </h2>
[[File:RoundRobin2cpu.png]]

ProvaTeorica 2013.02.14

2014-05-13T14:22:57Z

Stanislao: Blanked the page

ProvaTeorica 2013.02.15

2014-05-13T14:22:21Z

Stanislao:

<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.02.15.tot.pdf Testo del compito]</h1>

Esercizio c.1

<syntaxhighlight lang="C">
/*
Esercizio c.1: (a) Scrivere un monitor dualwriter che realizzi un doppio buffer limitato (ogni buffer ha ampiezza
BUFSIZE) che consenta a uno scrittore di scrivere contemporaneamente due elementi che andranno rispettivamente
nel primo e nel secondo buffer. Le letture :
procedure entry void write(type1 e1, type2 e2);
procedure entry type1 read1();
procedure entry type2 read2();
La funzione write deve attendere che ci sia spazio in entrambi i buffer.
La funzione read attende che vi sia almeno un elemento nel buffer indicato
*/
monitor dualwriter
{
type1* buffer1;
type2* buffer2;
condition oktowrite,oktoread1, oktoread2
procedure entry void write (type1 e1, type2 e2)
{
if (sizeof(type1)>=BUFSIZE || sizeof(type2)>=BUFSIZE)
oktowrite.wait();
buffer1.push(e1);
buffer2.push(e2);
oktoread1.signal();
oktoread2.signal();
}

procedure entry type1 read1()
{
if (sizeof(buffer1)==0)
oktoread1.wait();
buffer1.pop();
if (sizeof(buffer2)<BUFSIZE)
oktowrite.signal();
}

procedure entry type2 read2()
{
if (sizeof(buffer2)==0)
oktoread2.wait();
buffer2.pop();
if (sizeof(buffer1)<BUFSIZE)
oktowrite.signal();
}
}
</syntaxhighlight>
-stefano92

----

<syntaxhighlight lang="C">
monitor dualwriter{
queue buffer1;
queue buffer2;
condition oktowrite;
condition oktoread1;
condition oktoread2;

procedure entry void write(type1 e1, type2 e2){
if((buffer1.len() == BUFSIZE) || (buffer2.len() == BUFSIZE)) /*se uno dei due buffer è pieno non puoi inserire*/
oktowrite.wait();

buffer1.enqueue(e1);
buffer2.enqueue(e2);

oktoread1.signal();
oktoread2.signal();
}

procedure entry type1 read1(){
if(buffer1.len() == 0) /*buffer vuoto*/
oktoread1.wait();

buffer1.dequeue;
oktowrite.signal();
}

procedure entry type2 read2(){
if(buffer2.len() == 0) /*buffer vuoto*/
oktoread2.wait();

buffer2.dequeue;
oktowrite.signal();
}
}
</syntaxhighlight>
Giulia
<h2> Esercizio c.2 </h2>

<h2> Esercizio g.1 </h2>
[[File:RoundRobin2cpu.png]]

ProvaTeorica 2013.05.30

2014-05-12T15:09:58Z

Stanislao:

<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.05.30.tot.pdf Testo del compito]</h1>

<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>

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

ProvaTeorica 2013.05.30

2014-05-12T13:39:05Z

Stanislao:

ProvaTeorica 2013.02.14

2014-05-09T15:14:22Z

Stanislao:

<h1> [http://www.cs.unibo.it/~renzo/so/compiti/2013.02.15.tot.pdf Testo Compito]</h1>

<h2> Esercizio c.2 </h2>
<syntaxhighlight lang="C">

// foo(x,y) <x=2+y , y=2+x>

int g = 0;

csenter:

do
int l;
foo(l, g);
while(l!=2)

csexit:

g = 0;

// funziona anche in caso di overflow

</syntaxhighlight>

ProvaTeorica 2013.02.14

2014-05-09T15:14:07Z

Stanislao:

<h1> [http://www.cs.unibo.it/~renzo/so/compiti/2013.02.15.tot.pdf Testo Compito]</h1>

<h2> Esercizio c.2 </h2>
<syntaxhighlight lang="C">

// foo(x,y) <x=2+y , y=2+x>

int g = 0;

csenter:

do
int l;
foo(l, g);
while(l!=2)

csexit:

g = 0;

funziona anche in caso di overflow

</syntaxhighlight>

ProvaTeorica 2013.02.14

2014-05-09T15:10:44Z

Stanislao:

ProvaTeorica 2013.02.14

2014-05-09T15:00:35Z

Stanislao:

<h2> Esercizio c.2 </h2>
<syntaxhighlight lang="C">

// foo(x,y) <x=2+y , y=2+x>

int g = 0;

csenter:

do
int l;
foo(l, g);
while(l!=2)

csexit:

g = 0;

</syntaxhighlight>

ProvaTeorica 2013.02.14

2014-05-09T14:55:07Z

Stanislao: Created page with "<h2> Esercizio c.2 </h2>"

<h2> Esercizio c.2 </h2>

Main Page

2014-05-09T14:54:26Z

Stanislao:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizi a caso del Prof.]]

[[Decalogo di Programmazione Concorrente]]

[[Python Programma tieni punteggio.]]

[[Comandi visti alle lezioni.]]

[[SYS CALL viste a lezione.]]

[[Parametri con getopt().]]

[[Funzione con numero variabile di parametri.]]

[[stampf - implementazione ridotta della printf.]]

[[Producer&Consumer MP.]]

[[ProvaPratica 2014.01.23]]

[[ProvaPratica 2013.09.13]]

[[ProvaPratica 2013.07.18]]

[[ProvaPratica 2013.06.21]]

[[ProvaPratica 2013.05.29]]

[[ProvaPratica 2013.02.15]]

[[ProvaPratica 2013.01.25]]

[[ProvaPratica 2012.09.19]]

[[ProvaPratica 2005.02.10]]

[[ProvaTeoria_2011.07.25]]

[[ProvaTeorica_2012.02.09]]

[[ProvaTeorica_2012.05.24]]

[[ProvaTeorica_2012.06.15]]

[[ProvaTeorica_2012.09.18]]

[[ProvaTeorica_2013.02.15]]

[[ProvaTeorica_2011.02.11]]

[[ProvaTeorica 2013.07.19]]

[[ProvaTeorica 2013.01.24]]

[[ProvaTeorica 2014.01.22]]

[[ProvaTeorica 2012.07.16]]

[[ProvaPratica_2010.07.12]]

[[Prova Teorica 2008.01.16]]

[[Prova Teorica 2013.09.12]]

[[Prova Teorica 2009.09.18]]

[[Prova Teorica 2008.09.17]]

[[Prova Teorica 2007.09.07]]

[[Prova Teorica 2013.06.21]]

[[ProvaPratica 2010.02.03]]

[[ProvaPratica 2011.09.12]]

[[ProvaPratica 2009.02.12]]

[[ProvaPratica 2009.01.15]]

[[Prova Teorica 2007.07.12]]

[[ProvaTeoria 2011.01.17]]

[[ProvaTeoria 2010.05.12]]

[[ProvaTeoria 2012.01.12]]

[[ProvaPratica 2009.09.23]]

[[ProvaPratica 2012.06.20]]

[[ProvaPratica 2010.07.19]]

[[ProvaTeorica 2013.05.30]]

[[ProvaTeoria_2009.01.30]]

[[ProvaTeoria_2012.01.12]]

[[ProvaPratica 2009.06.23]]

[[ProvaTeorica 2013.02.14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

ProvaTeorica 2013.05.30

2014-05-04T15:38:10Z

Stanislao:

<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>

<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>

<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>

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

File:Holt.png

2014-05-04T13:58:30Z

Stanislao:

ProvaTeorica 2013.05.30

2014-05-04T13:58:04Z

Stanislao:

ProvaTeorica 2013.05.30

2014-05-03T17:12:00Z

Stanislao:

ProvaTeorica 2013.05.30

2014-05-02T16:09:12Z

Stanislao:

ProvaTeorica 2013.05.30

2014-05-02T16:05:04Z

Stanislao:

<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>

<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>

ProvaTeorica 2013.05.30

2014-05-02T16:03:18Z

Stanislao:

<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>

<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>

ProvaTeorica 2013.05.30

2014-05-02T14:58:19Z

Stanislao:

ProvaTeorica 2013.05.30

2014-05-02T14:54:10Z

Stanislao:

<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>

ProvaTeorica 2013.05.30

2014-05-02T14:53:13Z

Stanislao:

<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;
usigned 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>

ProvaTeorica 2013.05.30

2014-05-02T14:52:45Z

Stanislao:

<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;
usigned 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 lang="C">

ProvaTeorica 2013.05.30

2014-05-02T14:52:32Z

Stanislao:

<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;
usigned 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 lang="C">

ProvaTeorica 2013.05.30

2014-05-02T14:52:05Z

Stanislao:

<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;
usigned 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 lang="C">

ProvaTeorica 2013.05.30

2014-05-02T14:51:39Z

Stanislao:

<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;
usigned 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 lang="C">

ProvaTeorica 2013.05.30

2014-05-02T14:49:14Z

Stanislao:

<h2>Esercizio c.1</<h2>

/* 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;
usigned 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);
}
<h2> Esercizio g.1 </h2>

Main Page

2014-05-02T14:47:41Z

Stanislao:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizi a caso del Prof.]]

[[Decalogo di Programmazione Concorrente]]

[[Python Programma tieni punteggio.]]

[[Comandi visti alle lezioni.]]

[[SYS CALL viste a lezione.]]

[[Parametri con getopt().]]

[[Funzione con numero variabile di parametri.]]

[[stampf - implementazione ridotta della printf.]]

[[Producer&Consumer MP.]]

[[ProvaPratica 2014.01.23]]

[[ProvaPratica 2013.09.13]]

[[ProvaPratica 2013.07.18]]

[[ProvaPratica 2013.06.21]]

[[ProvaPratica 2013.05.29]]

[[ProvaPratica 2013.02.15]]

[[ProvaPratica 2013.01.25]]

[[ProvaPratica 2012.09.19]]

[[ProvaPratica 2005.02.10]]

[[ProvaTeoria_2011.07.25]]

[[ProvaTeorica_2012.02.09]]

[[ProvaTeorica_2012.05.24]]

[[ProvaTeorica_2012.06.15]]

[[ProvaTeorica_2012.09.18]]

[[ProvaTeorica_2013.02.15]]

[[ProvaTeorica_2011.02.11]]

[[ProvaTeorica 2013.07.19]]

[[ProvaTeorica 2013.01.24]]

[[ProvaTeorica 2014.01.22]]

[[ProvaTeorica 2012.07.16]]

[[ProvaPratica_2010.07.12]]

[[Prova Teorica 2008.01.16]]

[[Prova Teorica 2013.09.12]]

[[Prova Teorica 2009.09.18]]

[[Prova Teorica 2008.09.17]]

[[Prova Teorica 2007.09.07]]

[[Prova Teorica 2013.06.21]]

[[ProvaPratica 2010.02.03]]

[[ProvaPratica 2011.09.12]]

[[ProvaPratica 2009.02.12]]

[[ProvaPratica 2009.01.15]]

[[Prova Teorica 2007.07.12]]

[[ProvaTeoria 2011.01.17]]

[[ProvaTeoria 2010.05.12]]

[[ProvaTeoria 2012.01.12]]

[[ProvaPratica 2009.09.23]]

[[ProvaPratica 2012.06.20]]

[[ProvaPratica 2010.07.19]]

[[ProvaTeorica 2013.05.30]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

File:RoundRobin2cpu.png

2014-05-02T13:30:57Z

Stanislao:

ProvaTeorica 2013.02.15

2014-05-02T13:30:40Z

Stanislao:

<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.02.15.tot.pdf Testo del compito]</h1>

Esercizio 1

<syntaxhighlight lang="C">
/*
Esercizio c.1: (a) Scrivere un monitor dualwriter che realizzi un doppio buffer limitato (ogni buffer ha ampiezza
BUFSIZE) che consenta a uno scrittore di scrivere contemporaneamente due elementi che andranno rispettivamente
nel primo e nel secondo buffer. Le letture :
procedure entry void write(type1 e1, type2 e2);
procedure entry type1 read1();
procedure entry type2 read2();
La funzione write deve attendere che ci sia spazio in entrambi i buffer.
La funzione read attende che vi sia almeno un elemento nel buffer indicato
*/
monitor dualwriter
{
type1* buffer1;
type2* buffer2;
condition oktowrite,oktoread1, oktoread2
procedure entry void write (type1 e1, type2 e2)
{
if (sizeof(type1)>=BUFSIZE || sizeof(type2)>=BUFSIZE)
oktowrite.wait();
buffer1.push(e1);
buffer2.push(e2);
oktoread1.signal();
oktoread2.signal();
}

procedure entry type1 read1()
{
if (sizeof(buffer1)==0)
oktoread1.wait();
buffer1.pop();
if (sizeof(buffer2)<BUFSIZE)
oktowrite.signal();
}

procedure entry type2 read2()
{
if (sizeof(buffer2)==0)
oktoread2.wait();
buffer2.pop();
if (sizeof(buffer1)<BUFSIZE)
oktowrite.signal();
}
}
</syntaxhighlight>
-stefano92

<h2> Esercizio g.1 </h2>
[[File:RoundRobin2cpu.png]]

File:DoppiaCpu.png

2014-05-02T13:24:16Z

Stanislao:

ProvaTeorica 2014.01.22

2014-05-02T13:00:10Z

Stanislao: /* Esercizio g.1 */

<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2014.01.22.tot.pdf Testo del compito]</h1>

<syntaxhighlight lang="C">

URL: http://www.cs.unibo.it/~renzo/so/compiti/2014.01.22.tot.pdf

@author: Alessandro

monitor bridge {
condition oktomove; /* auto attraversa il ponte */
int turn=0; /*indica il senso delle auto */
int est=0,ovest=0; /*contatori delle auto da est e da ovest */
Queue q; /*coda delle senso delle macchine in attesa */

procedure entry enter (char EoW)
{
if(EoW == "E") /* viene da est */
{
if(turn == 2 || est >=N || !empty(q))
{
q=enqueue("E"); /*inserisco nella coda dei sensi*/
oktomove.wait(); /*aspetta*/

}
turn = 1; /*impongo il senso delle auto in circolo nel ponte */
est++;
}
else /* viene da ovest */
{
if(turn ==1 || ovest >=N || !empty(q))
{
q=enqueue("O"); /*inserisco nella coda dei sensi*/
oktomove.wait(); /*aspetta*/

}
turn = 2; /*impongo il senso delle auto in circolo nel ponte */
ovest++;
}
}

procedure entry exit(char EoW)
{
char r;
if(EoW == "O")
{
est--;
r=head(q); /* leggo la prossima auto che aspetta di entrare */
if(est == 0 || r == "E") /*nessuna auto in transito nel ponte o il prossimo va nella stessa direzione*/
{
est--;
if(est == 0) /*nessuna auto in transito nel ponte */
{
turn = 0; /*avanti un altro */
}
if(!empty(q))
{
q.dequeue();
oktomove.signal(); /*segnale*/
}
}
else
{
ovest--;
r=head(q); /* leggo la prossima auto che aspetta di entrare */
if(ovest == 0 || r == "O") /*nessuna auto in transito nel ponte o il prossimo va nella stessa direzione*/
{
turn = 0; /*avanti un altro */
}
if(!empty(q))
{
q.dequeue();
oktomove.signal(); /*segnale*/
}
}
}

}
</syntaxhighlight>

------

<syntaxhighlight lang="C">
/*
* URL: http://www.cs.unibo.it/~renzo/so/compiti/2014.01.22.tot.pdf
* author: Tommaso Ognibene
*/

monitor bridge
{
condition okE; // attraversare in direzione Est
condition okW; // attraversare in direzione Ovest
int n = 0; // numero di veicoli sul ponte
int waitingE = 0; // numero di veicoli che attendono di attraversare in direzione Est
int waitingW = 0; // numero di veicoli che attendono di attraversare in direzione Ovest
bool toE = true; // direzione di attraversamento

procedure entry enter(Vehicle vehicle)
{
// [Case 1] Il veicolo vuole attraversare in direzione Ovest
if (vehicle.To == 'W')
{
/* Se - il numero di veicoli sul ponte ha raggiunto il massimo; oppure
- qualcuno sta attraversando in direzione opposta; oppure
- qualcuno sta attendendo di attraversare in direzione opposta */
if (n == N || (toE && n > 0) || (!toE && waitingE > 0))
{
// Mi fermo e attendo di essere sbloccato
waitingW++;
okW.wait();
waitingW--;
}
toE = false;
n++;

/* Se possibile, sblocco eventuali altri veicoli in attesa per la stessa direzione.
* Questo non crea starvation in quanto sono sicuramente un numero limitato. */
if (n < N && waitingE == 0)
okW.signal();
}
// [Case 2] Il veicolo vuole attraversare in direzione Est
else
{
/* Se - il numero di veicoli sul ponte ha raggiunto il massimo; oppure
- qualcuno sta attraversando in direzione opposta; oppure
- qualcuno sta attendendo di attraversare in direzione opposta */
if (n == N || (!toE && n > 0) || (toE && waitingW > 0))
{
// Mi fermo e attendo di essere sbloccato
waitingE++;
okE.wait();
waitingE--;
}
toE = true;
n++;

/* Se possibile, sblocco eventuali altri veicoli in attesa per la stessa direzione.
* Questo non crea starvation in quanto sono sicuramente un numero limitato. */
if (n < N && waitingW == 0)
okE.signal();
}
}

procedure entry exit(Vehicle vehicle)
{
n--;
/* Se nessuno sta attraversando il ponte */
if (n == 0)
{
// [Case 1] L'ultimo ad attraversare andava in direzione Ovest
if (vehicle.To == 'W')
{
/* Se esiste, attivo il veicolo che per primo si era messo
in attesa per la direzione opposta */
if (waitingE > 0)
okE.signal();
else
okW.signal();
}
// [Case 2] L'ultimo ad attraversare andava in direzione Est
else
{
/* Se esiste, attivo il veicolo che per primo si era messo
in attesa per la direzione opposta */
if (waitingW > 0)
okW.signal();
else
okE.signal();
}
}
}
}
</syntaxhighlight>

La Mia soluzione:
<syntaxhighlight lang="C">
/*
* author: Midolo
*/

Monitor Ponte {
#define O 0
#define E 1
condition oktocross[2];
int countwaiting[2], crossing;

bridge.enter(dir){
if(crossing != 0 || countwaiting[1-dir] != 0){
countwaiting[dir]++;
oktocross[dir].wait();
countwaiting[dir]--;
}
crossing++;
if(crossing < N){
oktocross[dir].signal();
}
}

bridge.exit(dir){
crossing--;
if(crossing == 0){
if(countwaiting[dir] != 0){
oktocross[dir].signal();
}else{
oktocross[1-dir].signal();
}
}

}
}
</syntaxhighlight>

== Esercizio g.1==

<syntaxhighlight lang="C">
"Punto a"
123456789123456789123456789...

111111111111111111111111111
22222222222222222222222222 MIN e MAXNUM (infiniti page fault)
3456789993456789993456789

"Punto b"
123453453453453453453453453...

111111111111111111111111111
22222222222222222222222222 MIN e MAXNUM (page fault ad ogni accesso)
3453453453453453453453453

</syntaxhighlight >

ProvaTeorica 2014.01.22

2014-05-02T12:59:34Z

Stanislao: /* Esercizio g.1 */

<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2014.01.22.tot.pdf Testo del compito]</h1>

<syntaxhighlight lang="C">

URL: http://www.cs.unibo.it/~renzo/so/compiti/2014.01.22.tot.pdf

@author: Alessandro

monitor bridge {
condition oktomove; /* auto attraversa il ponte */
int turn=0; /*indica il senso delle auto */
int est=0,ovest=0; /*contatori delle auto da est e da ovest */
Queue q; /*coda delle senso delle macchine in attesa */

procedure entry enter (char EoW)
{
if(EoW == "E") /* viene da est */
{
if(turn == 2 || est >=N || !empty(q))
{
q=enqueue("E"); /*inserisco nella coda dei sensi*/
oktomove.wait(); /*aspetta*/

}
turn = 1; /*impongo il senso delle auto in circolo nel ponte */
est++;
}
else /* viene da ovest */
{
if(turn ==1 || ovest >=N || !empty(q))
{
q=enqueue("O"); /*inserisco nella coda dei sensi*/
oktomove.wait(); /*aspetta*/

}
turn = 2; /*impongo il senso delle auto in circolo nel ponte */
ovest++;
}
}

procedure entry exit(char EoW)
{
char r;
if(EoW == "O")
{
est--;
r=head(q); /* leggo la prossima auto che aspetta di entrare */
if(est == 0 || r == "E") /*nessuna auto in transito nel ponte o il prossimo va nella stessa direzione*/
{
est--;
if(est == 0) /*nessuna auto in transito nel ponte */
{
turn = 0; /*avanti un altro */
}
if(!empty(q))
{
q.dequeue();
oktomove.signal(); /*segnale*/
}
}
else
{
ovest--;
r=head(q); /* leggo la prossima auto che aspetta di entrare */
if(ovest == 0 || r == "O") /*nessuna auto in transito nel ponte o il prossimo va nella stessa direzione*/
{
turn = 0; /*avanti un altro */
}
if(!empty(q))
{
q.dequeue();
oktomove.signal(); /*segnale*/
}
}
}

}
</syntaxhighlight>

------

<syntaxhighlight lang="C">
/*
* URL: http://www.cs.unibo.it/~renzo/so/compiti/2014.01.22.tot.pdf
* author: Tommaso Ognibene
*/

monitor bridge
{
condition okE; // attraversare in direzione Est
condition okW; // attraversare in direzione Ovest
int n = 0; // numero di veicoli sul ponte
int waitingE = 0; // numero di veicoli che attendono di attraversare in direzione Est
int waitingW = 0; // numero di veicoli che attendono di attraversare in direzione Ovest
bool toE = true; // direzione di attraversamento

procedure entry enter(Vehicle vehicle)
{
// [Case 1] Il veicolo vuole attraversare in direzione Ovest
if (vehicle.To == 'W')
{
/* Se - il numero di veicoli sul ponte ha raggiunto il massimo; oppure
- qualcuno sta attraversando in direzione opposta; oppure
- qualcuno sta attendendo di attraversare in direzione opposta */
if (n == N || (toE && n > 0) || (!toE && waitingE > 0))
{
// Mi fermo e attendo di essere sbloccato
waitingW++;
okW.wait();
waitingW--;
}
toE = false;
n++;

/* Se possibile, sblocco eventuali altri veicoli in attesa per la stessa direzione.
* Questo non crea starvation in quanto sono sicuramente un numero limitato. */
if (n < N && waitingE == 0)
okW.signal();
}
// [Case 2] Il veicolo vuole attraversare in direzione Est
else
{
/* Se - il numero di veicoli sul ponte ha raggiunto il massimo; oppure
- qualcuno sta attraversando in direzione opposta; oppure
- qualcuno sta attendendo di attraversare in direzione opposta */
if (n == N || (!toE && n > 0) || (toE && waitingW > 0))
{
// Mi fermo e attendo di essere sbloccato
waitingE++;
okE.wait();
waitingE--;
}
toE = true;
n++;

/* Se possibile, sblocco eventuali altri veicoli in attesa per la stessa direzione.
* Questo non crea starvation in quanto sono sicuramente un numero limitato. */
if (n < N && waitingW == 0)
okE.signal();
}
}

procedure entry exit(Vehicle vehicle)
{
n--;
/* Se nessuno sta attraversando il ponte */
if (n == 0)
{
// [Case 1] L'ultimo ad attraversare andava in direzione Ovest
if (vehicle.To == 'W')
{
/* Se esiste, attivo il veicolo che per primo si era messo
in attesa per la direzione opposta */
if (waitingE > 0)
okE.signal();
else
okW.signal();
}
// [Case 2] L'ultimo ad attraversare andava in direzione Est
else
{
/* Se esiste, attivo il veicolo che per primo si era messo
in attesa per la direzione opposta */
if (waitingW > 0)
okW.signal();
else
okE.signal();
}
}
}
}
</syntaxhighlight>

La Mia soluzione:
<syntaxhighlight lang="C">
/*
* author: Midolo
*/

Monitor Ponte {
#define O 0
#define E 1
condition oktocross[2];
int countwaiting[2], crossing;

bridge.enter(dir){
if(crossing != 0 || countwaiting[1-dir] != 0){
countwaiting[dir]++;
oktocross[dir].wait();
countwaiting[dir]--;
}
crossing++;
if(crossing < N){
oktocross[dir].signal();
}
}

bridge.exit(dir){
crossing--;
if(crossing == 0){
if(countwaiting[dir] != 0){
oktocross[dir].signal();
}else{
oktocross[1-dir].signal();
}
}

}
}
</syntaxhighlight>

== Esercizio g.1==

<syntaxhighlight lang="C">
"Punto a"
123456789123456789123456789...

111111111111111111111111111
22222222222222222222222222 MIN e MAXNUM (finiti page fault)
3456789993456789993456789

"Punto b"
123453453453453453453453453...

111111111111111111111111111
22222222222222222222222222 MIN e MAXNUM (page fault ad ogni accesso)
3453453453453453453453453

</syntaxhighlight >

ProvaTeorica 2013.02.15

2014-04-30T15:46:20Z

Stanislao:

ProvaTeorica 2013.02.15

2014-04-30T13:59:17Z

Stanislao:

Main Page

2014-04-30T13:56:40Z

Stanislao:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizi a caso del Prof.]]

[[Decalogo di Programmazione Concorrente]]

[[Python Programma tieni punteggio.]]

[[Comandi visti alle lezioni.]]

[[SYS CALL viste a lezione.]]

[[Parametri con getopt().]]

[[Funzione con numero variabile di parametri.]]

[[stampf - implementazione ridotta della printf.]]

[[Producer&Consumer MP.]]

[[ProvaPratica 2014.01.23]]

[[ProvaPratica 2013.09.13]]

[[ProvaPratica 2013.07.18]]

[[ProvaPratica 2013.06.21]]

[[ProvaPratica 2013.05.29]]

[[ProvaPratica 2013.02.15]]

[[ProvaPratica 2013.01.25]]

[[ProvaPratica 2012.09.19]]

[[ProvaPratica 2005.02.10]]

[[ProvaTeoria_2011.07.25]]

[[ProvaTeorica_2012.02.09]]

[[ProvaTeorica_2012.05.24]]

[[ProvaTeorica_2012.06.15]]

[[ProvaTeorica_2012.09.18]]

[[ProvaTeorica_2013.02.15]]

[[ProvaTeorica_2011.02.11]]

[[ProvaTeorica 2013.07.19]]

[[ProvaTeorica 2013.01.24]]

[[ProvaTeorica 2014.01.22]]

[[ProvaTeorica 2012.07.16]]

[[ProvaPratica_2010.07.12]]

[[Prova Teorica 2008.01.16]]

[[Prova Teorica 2013.09.12]]

[[Prova Teorica 2009.09.18]]

[[Prova Teorica 2008.09.17]]

[[Prova Teorica 2007.09.07]]

[[Prova Teorica 2013.06.21]]

[[ProvaPratica 2010.02.03]]

[[ProvaPratica 2011.09.12]]

[[ProvaPratica 2009.02.12]]

[[ProvaPratica 2009.01.15]]

[[Prova Teorica 2007.07.12]]

[[ProvaTeoria 2011.01.17]]

[[ProvaTeoria 2010.05.12]]

[[ProvaTeoria 2012.01.12]]

[[ProvaPratica 2009.09.23]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

ProvaTeorica 2013.05.30

2014-04-30T13:53:57Z

Stanislao: Created page with "<h1> Esercizio 1g </h1> File:espag.jpg"

<h1> Esercizio 1g </h1>
[[File:espag.jpg]]

Main Page

2014-04-30T13:51:07Z

Stanislao:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizi a caso del Prof.]]

[[Decalogo di Programmazione Concorrente]]

[[Python Programma tieni punteggio.]]

[[Comandi visti alle lezioni.]]

[[SYS CALL viste a lezione.]]

[[Parametri con getopt().]]

[[Funzione con numero variabile di parametri.]]

[[stampf - implementazione ridotta della printf.]]

[[Producer&Consumer MP.]]

[[ProvaPratica 2014.01.23]]

[[ProvaPratica 2013.09.13]]

[[ProvaPratica 2013.07.18]]

[[ProvaPratica 2013.06.21]]

[[ProvaPratica 2013.05.29]]

[[ProvaPratica 2013.02.15]]

[[ProvaPratica 2013.01.25]]

[[ProvaPratica 2012.09.19]]

[[ProvaPratica 2005.02.10]]

[[ProvaTeoria_2011.07.25]]

[[ProvaTeorica_2012.02.09]]

[[ProvaTeorica_2012.05.24]]

[[ProvaTeorica_2012.06.15]]

[[ProvaTeorica_2012.09.18]]

[[ProvaTeorica_2013.05.30]]

[[ProvaTeorica_2011.02.11]]

[[ProvaTeorica 2013.07.19]]

[[ProvaTeorica 2013.01.24]]

[[ProvaTeorica 2014.01.22]]

[[ProvaTeorica 2012.07.16]]

[[ProvaPratica_2010.07.12]]

[[Prova Teorica 2008.01.16]]

[[Prova Teorica 2013.09.12]]

[[Prova Teorica 2009.09.18]]

[[Prova Teorica 2008.09.17]]

[[Prova Teorica 2007.09.07]]

[[Prova Teorica 2013.06.21]]

[[ProvaPratica 2010.02.03]]

[[ProvaPratica 2011.09.12]]

[[ProvaPratica 2009.02.12]]

[[ProvaPratica 2009.01.15]]

[[Prova Teorica 2007.07.12]]

[[ProvaTeoria 2011.01.17]]

[[ProvaTeoria 2010.05.12]]

[[ProvaTeoria 2012.01.12]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

ProvaTeorica 2013.02.15

2014-04-29T18:41:05Z

Stanislao:

Esercizio 1

<syntaxhighlight lang="C">
/*
Esercizio c.1: (a) Scrivere un monitor dualwriter che realizzi un doppio buffer limitato (ogni buffer ha ampiezza
BUFSIZE) che consenta a uno scrittore di scrivere contemporaneamente due elementi che andranno rispettivamente
nel primo e nel secondo buffer. Le letture :
procedure entry void write(type1 e1, type2 e2);
procedure entry type1 read1();
procedure entry type2 read2();
La funzione write deve attendere che ci sia spazio in entrambi i buffer.
La funzione read attende che vi sia almeno un elemento nel buffer indicato
*/
monitor dualwriter
{
type1* buffer1;
type2* buffer2;
condition oktowrite,oktoread1, oktoread2
procedure entry void write (type1 e1, type2 e2)
{
if (sizeof(type1)>=BUFSIZE || sizeof(type2)>=BUFSIZE)
oktowrite.wait();
buffer1.push(e1);
buffer2.push(e2);
oktoread1.signal();
oktoread2.signal();
}

procedure entry type1 read1()
{
if (sizeof(buffer1)==0)
oktoread1.wait();
buffer1.pop();
if (sizeof(buffer2)<BUFSIZE)
oktowrite.signal();
}

procedure entry type2 read2()
{
if (sizeof(buffer2)==0)
oktoread2.wait();
buffer2.pop();
if (sizeof(buffer1)<BUFSIZE)
oktowrite.signal();
}
}
</syntaxhighlight>
-stefano92

<h2> Esercizio g.1 </h2>
[[File:Espag.jpg]]

File:Espag.jpg

2014-04-29T18:39:25Z

Stanislao:

Prova Teorica 2013.06.21

2014-04-28T15:02:00Z

Stanislao:

<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.06.21.tot.pdf Testo del compito]</h1>
<h2> Esercizio g.1 </h2>
[[http://so.v2.cs.unibo.it/wiki/images/0/02/G1paginazione.jpg soluzione]]

Prova Teorica 2013.06.21

2014-04-28T14:59:41Z

Stanislao:

<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.06.21.tot.pdf Testo del compito]</h1>
<h2> Esercizio g.1 </h2>
[[File:G1paginazione.jpg]]

Prova Teorica 2013.06.21

2014-04-28T14:53:06Z

Stanislao:

<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.06.21.tot.pdf Testo del compito]</h1>
<h2> Esercizio g.1 </h2>

File:G1paginazione.jpg

2014-04-28T14:35:55Z

Stanislao: Stanislao uploaded a new version of "File:G1paginazione.jpg"

File:G1paginazione.jpg

2014-04-28T14:33:27Z

Stanislao: Stanislao uploaded a new version of "File:G1paginazione.jpg": Reverted to version as of 14:30, 28 April 2014

File:G1paginazione.jpg

2014-04-28T14:33:08Z

Stanislao: Stanislao uploaded a new version of "File:G1paginazione.jpg"

File:G1paginazione.jpg

2014-04-28T14:30:45Z

Stanislao: Stanislao uploaded a new version of "File:G1paginazione.jpg"

Prova Teorica 2013.06.21

2014-04-28T13:30:32Z

Stanislao:

<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.06.21.tot.pdf Testo del compito]</h1>
<h2> Esercizio g.1 </h2>
[[File:G1paginazione.jpg]]