Sistemi Operativi - User contributions [en]

Prova teorica 2017.05.29

2017-07-13T09:19:57Z

Save: /* Soluzione di Mida */

[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf link al compito]

==Esercizio c.1==
===Soluzione di Mida===
<syntaxhighlight lang="C">

Monitor rb()
{

condition oktorun, oktochiama
int c, punteggio[2], nstudentiP, arrivati
int i = [1,2,3,4]

procedure entry nuovaPartita ()
{
punteggio[A] = punteggio [B] = c = arrivati = 0;

}

procedure entry chiama( n )

{
int k = random(i);
c = k;
if ( nstudentiP < 2 * MAX )
oktochiama(n).wait();
for(j=0 ; j<k ; k++)
n inrange(0, MAX-1);
oktorun(n).signal();
return Punteggio

}

procedure entry pronto (sq, n)

{
if(max(punteggio) == 10;
return 1

nstudentiP ++;
if ( nstudentiP >= 2*MAX )
oktochiama(n).signal();
oktorun(n).wait();
arrivati(sq)++;
else return 0

}

procedure entry allabandiera ( sq, n)

{
if ( arrivati(sq) == C )
punteggio[sq]++;
else punteggio[1-sq]++;

}
}

qualcuno cortesemente può dirmi se può andar bene?
</syntaxhighlight>

===Soluzione di Stefano Zaniboni===

<syntaxhighlight lang="C">
Monitor rb () {

condition ok2chiama, ok2run[MAX], ok2fine
int npronti, punteggio[2], arrivati, c

procedure entry void nuovapartita() {
c = npronti = arrived punteggio[0] = punteggio[1] = 0
}
procedure entry int chiama(int *chiamati) {
c = chiamati.length
if(npronti < 2 * MAX)
ok2chiama.wait()
for(int i = 0; i < c; i++){
ok2run[i].signal()
ok2run[i].signal()
}
ok2fine.wait()
if(max(punteggio) == 10)
for(int i = 0; i in range(MAX); i++){
ok2run[i].signal()
ok2run[i].signal()
}
return punteggio;
}

procedure entry int pronto(int squadra, int numero) {
if(max(punteggio) == 10)
return -1
npronti++
if (npronti > 2 * MAX)
ok2chiama.signal()
if(n not in chiamata)
ok2run[n].wait()
npronti--
if(max(punteggio) == 10)
return -1
else return 0
}

procedure entry void allabandiera(int squadra, int numero) {
arrived++
if(arrived = 2 * c)
punteggio[1 - squadra]++
ok2fine.signal()
}
}

</syntaxhighlight>

==Esercizio c.2==

===Soluzione di Stefano Zaniboni===
<syntaxhighlight lang="C">
/*
sia dato un servizio di message passing asincrono distratto. Questo servizio si comporta come un servizio di message passing asincrono ma talvolta dimentica la destinazione.
E’ però possibile indicare un processo come “ufficio messaggi smarriti” al quale verranno recapitati tutti i messaggi per i quali il servizio distratto ha dimenticato la destinazione.

Void dmsgsend(pid_t dest, msg_t msg); //si comporta come amsgsend ma può dimenticare la desticazione
msg_t dmsgrecv() //si comporta come amsgrecv(*)
void dset_lost_n_found(pid_t pid); //indica il processo per i messaggi smarriti.

Usando il servizio “distratto” e un processo “ufficio messaggi smarriti”,
implementare un servizio di message passing standard (senza la selezione del mittente in ricezione, la amsgrecv riceve da qualsiasi mittente).
*/

void asend(pid_t dest, msg_t msg){
dmsgsend(dest,{getpid(), dest, msg})
}

msg_t arecv(pid_t sender){
{snd, dst, m} = dmsgrecv()
return m
}

process l+f{
dset_lost_n_found(getpid())
while(true){
{snd, dst, m} = dmsgrecv()
if dst != getpid(){
asend(dst, {snd, dst, m})
}
}
}

</syntaxhighlight>

==Esercizio g.1==
===Soluzione di GiovanniF===

min = lifo 1234123124123124...

lifo = lru 123124123124123124...

--[[User:FedericoB|FedericoB]] ([[User talk:FedericoB|talk]]) 10:17, 16 June 2017 (CEST) <br>
Ho verificato la soluzione:<br>
Il ragionamento da fare qui è: <br>
MIN = LIFO <br>
MIN sceglie la pagina che più tardi nel futuro verrà richiesta <br>
LIFO sceglie l'ultima pagina caricata <br>
Quindi ad ogni page fault l'ultima pagina caricata deve essere quella che più tardi nel futuro verrà richiesta

<pre>
MIN
1 2 3 4 1 2 3 1 2 4 1 2 3 1 2 4
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
3 4 4 4 3 3 3 4 4 4 3 3 3 4
# # # # #

LIFO
1 2 3 4 1 2 3 1 2 4 1 2 3 1 2 4
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 1 2 2 2 2 2
3 4 4 4 3 3 3 4 4 4 3 3 3 4
# # # # #
</pre>

LIFO = LRU <br>
LRU sceglie la pagina che più precedentemente nel passato è stata richiesta <br>
Quindi ad ogni page fault l'ultima pagina caricata deve essere quella che più precedentemente nel passato è stata richiesta

<pre>
LRU
1 2 3 1 2 4 1 2 3 1 2 4 1 2 3
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 2 2 2 2 2
3 3 3 4 4 4 3 3 3 4 4 4 4
# # # #

LIFO
1 2 3 1 2 4 1 2 3 1 2 4 1 2 3
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 2 2 2 2 2
3 3 3 4 4 4 3 3 3 4 4 4 4
# # # #
</pre>

==Esercizio g.2==
#'''Un i-node di un file system tipo ext2 per un errore viene riportato un numero di link maggiore del reale. Cosa può succedere se si continua ad usare il file system? (perchè?) E se il numero di link errato fosse il contrario inferiore al reale cosa potrebbe succedere? (perchè?) ''' <br> Che quando i reali link al i-node verrano eliminati e il numero decrementato questo non raggiungerà mai zero e lo spazio non verrà rilasciato. Se invece il numero di link è inferiore al reale può succedere che con solo l'eliminazione di pochi link al inode l'area del file venga segnata come libera perchè il sistema operativo pensa che l'inode non sia più utilizzato.
#'''Perchè è necessario usare spinlock in sistemi multiprocessore per implementare kernel di tipo simmetrico (SMP)?''' <br>Perchè la semplice disabilitazione degli interrupt non sarebbe sufficiente in caso di parallelismo reale a prevenire l'accesso a memoria condivisa in concorrenza. Bisogna perciò utilizzare strumenti come gli spinlock che grazie a istruzioni atomiche, per esempio la test-and-set, bloccano l'esecuzione di un processo fino al verificarsi di una condizione. Per evitare il busy wait si possono usare gli spinlock solo per rendere atomiche le istruzioni P e V di un semaforo in modo che la maggior parte del tempo di attesa per entrare in una sezione critica un processo lo passi in stato di wait invece che consumare inutilmente cicli di CPU.
#'''Perchè nei sistemi reali l'algoritmo di rimpiazzamento second chance (orologio) viene preferito a LRU sebbene il primo non sia a stack e il secondo sì?''' <br> perchè la gestione dei timestamp richiesti da LRU è costosa nella MMU.
#'''Perchè revocare un'autorizzazione espressa come capability è più difficile che revocare lo stesso diritto quando espresso come access control list?''' <br> Perchè le capability sono salvate al interno dello spazio di memoria di ciascun processo mentre le access control list sono legate al file.

Prova teorica 2017.05.29

2017-07-13T09:19:07Z

Save: /* Esercizio c.1 */

[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf link al compito]

==Esercizio c.1==
===Soluzione di Mida===
<syntaxhighlight lang="C">

Monitor rb()
{

condition oktorun, oktochiama
int c, punteggio[2], nstudentiP, arrivati
int i = [1,2,3,4]

procedure entry nuovaPartita ()
{
punteggio[A] = punteggio [B] = c = arrivati = 0;

}

procedure entry chiama( n )

{
int k = random(i);
c = k;
if ( nstudentiP < 2 * MAX )
oktochiama(n).wait();
for(j=0 ; j<k ; k++)
n inrange(0, MAX-1);
oktorun(n).signal();
return Punteggio

}

procedure entry pronto (sq, n)

{
if(max(punteggio) == 10;
return 1

nstudentiP ++;
if ( nstudentiP >= 2*MAX )
oktochiama(n).signal();
oktorun(n).wait();
arrivati(sq)++;
else return 0

}

procedure entry allabandiera ( sq, n)

{
if ( arrivati(sq) == C )
punteggio[sq]++;
else punteggio[1-sq]++;

}
}

</syntaxhighlight>

===Soluzione di Stefano Zaniboni===

<syntaxhighlight lang="C">
Monitor rb () {

condition ok2chiama, ok2run[MAX], ok2fine
int npronti, punteggio[2], arrivati, c

procedure entry void nuovapartita() {
c = npronti = arrived punteggio[0] = punteggio[1] = 0
}
procedure entry int chiama(int *chiamati) {
c = chiamati.length
if(npronti < 2 * MAX)
ok2chiama.wait()
for(int i = 0; i < c; i++){
ok2run[i].signal()
ok2run[i].signal()
}
ok2fine.wait()
if(max(punteggio) == 10)
for(int i = 0; i in range(MAX); i++){
ok2run[i].signal()
ok2run[i].signal()
}
return punteggio;
}

procedure entry int pronto(int squadra, int numero) {
if(max(punteggio) == 10)
return -1
npronti++
if (npronti > 2 * MAX)
ok2chiama.signal()
if(n not in chiamata)
ok2run[n].wait()
npronti--
if(max(punteggio) == 10)
return -1
else return 0
}

procedure entry void allabandiera(int squadra, int numero) {
arrived++
if(arrived = 2 * c)
punteggio[1 - squadra]++
ok2fine.signal()
}
}

</syntaxhighlight>

==Esercizio c.2==

===Soluzione di Stefano Zaniboni===
<syntaxhighlight lang="C">
/*
sia dato un servizio di message passing asincrono distratto. Questo servizio si comporta come un servizio di message passing asincrono ma talvolta dimentica la destinazione.
E’ però possibile indicare un processo come “ufficio messaggi smarriti” al quale verranno recapitati tutti i messaggi per i quali il servizio distratto ha dimenticato la destinazione.

Void dmsgsend(pid_t dest, msg_t msg); //si comporta come amsgsend ma può dimenticare la desticazione
msg_t dmsgrecv() //si comporta come amsgrecv(*)
void dset_lost_n_found(pid_t pid); //indica il processo per i messaggi smarriti.

Usando il servizio “distratto” e un processo “ufficio messaggi smarriti”,
implementare un servizio di message passing standard (senza la selezione del mittente in ricezione, la amsgrecv riceve da qualsiasi mittente).
*/

void asend(pid_t dest, msg_t msg){
dmsgsend(dest,{getpid(), dest, msg})
}

msg_t arecv(pid_t sender){
{snd, dst, m} = dmsgrecv()
return m
}

process l+f{
dset_lost_n_found(getpid())
while(true){
{snd, dst, m} = dmsgrecv()
if dst != getpid(){
asend(dst, {snd, dst, m})
}
}
}

</syntaxhighlight>

==Esercizio g.1==
===Soluzione di GiovanniF===

min = lifo 1234123124123124...

lifo = lru 123124123124123124...

--[[User:FedericoB|FedericoB]] ([[User talk:FedericoB|talk]]) 10:17, 16 June 2017 (CEST) <br>
Ho verificato la soluzione:<br>
Il ragionamento da fare qui è: <br>
MIN = LIFO <br>
MIN sceglie la pagina che più tardi nel futuro verrà richiesta <br>
LIFO sceglie l'ultima pagina caricata <br>
Quindi ad ogni page fault l'ultima pagina caricata deve essere quella che più tardi nel futuro verrà richiesta

<pre>
MIN
1 2 3 4 1 2 3 1 2 4 1 2 3 1 2 4
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
3 4 4 4 3 3 3 4 4 4 3 3 3 4
# # # # #

LIFO
1 2 3 4 1 2 3 1 2 4 1 2 3 1 2 4
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 1 2 2 2 2 2
3 4 4 4 3 3 3 4 4 4 3 3 3 4
# # # # #
</pre>

LIFO = LRU <br>
LRU sceglie la pagina che più precedentemente nel passato è stata richiesta <br>
Quindi ad ogni page fault l'ultima pagina caricata deve essere quella che più precedentemente nel passato è stata richiesta

<pre>
LRU
1 2 3 1 2 4 1 2 3 1 2 4 1 2 3
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 2 2 2 2 2
3 3 3 4 4 4 3 3 3 4 4 4 4
# # # #

LIFO
1 2 3 1 2 4 1 2 3 1 2 4 1 2 3
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 2 2 2 2 2
3 3 3 4 4 4 3 3 3 4 4 4 4
# # # #
</pre>

==Esercizio g.2==
#'''Un i-node di un file system tipo ext2 per un errore viene riportato un numero di link maggiore del reale. Cosa può succedere se si continua ad usare il file system? (perchè?) E se il numero di link errato fosse il contrario inferiore al reale cosa potrebbe succedere? (perchè?) ''' <br> Che quando i reali link al i-node verrano eliminati e il numero decrementato questo non raggiungerà mai zero e lo spazio non verrà rilasciato. Se invece il numero di link è inferiore al reale può succedere che con solo l'eliminazione di pochi link al inode l'area del file venga segnata come libera perchè il sistema operativo pensa che l'inode non sia più utilizzato.
#'''Perchè è necessario usare spinlock in sistemi multiprocessore per implementare kernel di tipo simmetrico (SMP)?''' <br>Perchè la semplice disabilitazione degli interrupt non sarebbe sufficiente in caso di parallelismo reale a prevenire l'accesso a memoria condivisa in concorrenza. Bisogna perciò utilizzare strumenti come gli spinlock che grazie a istruzioni atomiche, per esempio la test-and-set, bloccano l'esecuzione di un processo fino al verificarsi di una condizione. Per evitare il busy wait si possono usare gli spinlock solo per rendere atomiche le istruzioni P e V di un semaforo in modo che la maggior parte del tempo di attesa per entrare in una sezione critica un processo lo passi in stato di wait invece che consumare inutilmente cicli di CPU.
#'''Perchè nei sistemi reali l'algoritmo di rimpiazzamento second chance (orologio) viene preferito a LRU sebbene il primo non sia a stack e il secondo sì?''' <br> perchè la gestione dei timestamp richiesti da LRU è costosa nella MMU.
#'''Perchè revocare un'autorizzazione espressa come capability è più difficile che revocare lo stesso diritto quando espresso come access control list?''' <br> Perchè le capability sono salvate al interno dello spazio di memoria di ciascun processo mentre le access control list sono legate al file.

Prova teorica 2017.05.29

2017-07-13T07:15:29Z

Save: /* Soluzione di Save */

[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf link al compito]

==Esercizio c.1==

===Soluzione di Stefano Zaniboni===

<syntaxhighlight lang="C">
Monitor rb () {

condition ok2chiama, ok2run[MAX], ok2fine
int npronti, punteggio[2], arrivati, c

procedure entry void nuovapartita() {
c = npronti = arrived punteggio[0] = punteggio[1] = 0
}
procedure entry int chiama(int *chiamati) {
c = chiamati.length
if(npronti < 2 * MAX)
ok2chiama.wait()
for(int i = 0; i < c; i++){
ok2run[i].signal()
ok2run[i].signal()
}
ok2fine.wait()
if(max(punteggio) == 10)
for(int i = 0; i in range(MAX); i++){
ok2run[i].signal()
ok2run[i].signal()
}
return punteggio;
}

procedure entry int pronto(int squadra, int numero) {
if(max(punteggio) == 10)
return -1
npronti++
if (npronti > 2 * MAX)
ok2chiama.signal()
if(n not in chiamata)
ok2run[n].wait()
npronti--
if(max(punteggio) == 10)
return -1
else return 0
}

procedure entry void allabandiera(int squadra, int numero) {
arrived++
if(arrived = 2 * c)
punteggio[1 - squadra]++
ok2fine.signal()
}
}

</syntaxhighlight>

==Esercizio c.2==

===Soluzione di Stefano Zaniboni===
<syntaxhighlight lang="C">
/*
sia dato un servizio di message passing asincrono distratto. Questo servizio si comporta come un servizio di message passing asincrono ma talvolta dimentica la destinazione.
E’ però possibile indicare un processo come “ufficio messaggi smarriti” al quale verranno recapitati tutti i messaggi per i quali il servizio distratto ha dimenticato la destinazione.

Void dmsgsend(pid_t dest, msg_t msg); //si comporta come amsgsend ma può dimenticare la desticazione
msg_t dmsgrecv() //si comporta come amsgrecv(*)
void dset_lost_n_found(pid_t pid); //indica il processo per i messaggi smarriti.

Usando il servizio “distratto” e un processo “ufficio messaggi smarriti”,
implementare un servizio di message passing standard (senza la selezione del mittente in ricezione, la amsgrecv riceve da qualsiasi mittente).
*/

void asend(pid_t dest, msg_t msg){
dmsgsend(dest,{getpid(), dest, msg})
}

msg_t arecv(pid_t sender){
{snd, dst, m} = dmsgrecv()
return m
}

process l+f{
dset_lost_n_found(getpid())
while(true){
{snd, dst, m} = dmsgrecv()
if dst != getpid(){
asend(dst, {snd, dst, m})
}
}
}

</syntaxhighlight>

==Esercizio g.1==
===Soluzione di GiovanniF===

min = lifo 1234123124123124...

lifo = lru 123124123124123124...

--[[User:FedericoB|FedericoB]] ([[User talk:FedericoB|talk]]) 10:17, 16 June 2017 (CEST) <br>
Ho verificato la soluzione:<br>
Il ragionamento da fare qui è: <br>
MIN = LIFO <br>
MIN sceglie la pagina che più tardi nel futuro verrà richiesta <br>
LIFO sceglie l'ultima pagina caricata <br>
Quindi ad ogni page fault l'ultima pagina caricata deve essere quella che più tardi nel futuro verrà richiesta

<pre>
MIN
1 2 3 4 1 2 3 1 2 4 1 2 3 1 2 4
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
3 4 4 4 3 3 3 4 4 4 3 3 3 4
# # # # #

LIFO
1 2 3 4 1 2 3 1 2 4 1 2 3 1 2 4
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 1 2 2 2 2 2
3 4 4 4 3 3 3 4 4 4 3 3 3 4
# # # # #
</pre>

LIFO = LRU <br>
LRU sceglie la pagina che più precedentemente nel passato è stata richiesta <br>
Quindi ad ogni page fault l'ultima pagina caricata deve essere quella che più precedentemente nel passato è stata richiesta

<pre>
LRU
1 2 3 1 2 4 1 2 3 1 2 4 1 2 3
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 2 2 2 2 2
3 3 3 4 4 4 3 3 3 4 4 4 4
# # # #

LIFO
1 2 3 1 2 4 1 2 3 1 2 4 1 2 3
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 2 2 2 2 2
3 3 3 4 4 4 3 3 3 4 4 4 4
# # # #
</pre>

==Esercizio g.2==
#'''Un i-node di un file system tipo ext2 per un errore viene riportato un numero di link maggiore del reale. Cosa può succedere se si continua ad usare il file system? (perchè?) E se il numero di link errato fosse il contrario inferiore al reale cosa potrebbe succedere? (perchè?) ''' <br> Che quando i reali link al i-node verrano eliminati e il numero decrementato questo non raggiungerà mai zero e lo spazio non verrà rilasciato. Se invece il numero di link è inferiore al reale può succedere che con solo l'eliminazione di pochi link al inode l'area del file venga segnata come libera perchè il sistema operativo pensa che l'inode non sia più utilizzato.
#'''Perchè è necessario usare spinlock in sistemi multiprocessore per implementare kernel di tipo simmetrico (SMP)?''' <br>Perchè la semplice disabilitazione degli interrupt non sarebbe sufficiente in caso di parallelismo reale a prevenire l'accesso a memoria condivisa in concorrenza. Bisogna perciò utilizzare strumenti come gli spinlock che grazie a istruzioni atomiche, per esempio la test-and-set, bloccano l'esecuzione di un processo fino al verificarsi di una condizione. Per evitare il busy wait si possono usare gli spinlock solo per rendere atomiche le istruzioni P e V di un semaforo in modo che la maggior parte del tempo di attesa per entrare in una sezione critica un processo lo passi in stato di wait invece che consumare inutilmente cicli di CPU.
#'''Perchè nei sistemi reali l'algoritmo di rimpiazzamento second chance (orologio) viene preferito a LRU sebbene il primo non sia a stack e il secondo sì?''' <br> perchè la gestione dei timestamp richiesti da LRU è costosa nella MMU.
#'''Perchè revocare un'autorizzazione espressa come capability è più difficile che revocare lo stesso diritto quando espresso come access control list?''' <br> Perchè le capability sono salvate al interno dello spazio di memoria di ciascun processo mentre le access control list sono legate al file.

Prova teorica 2017.05.29

2017-06-15T12:15:56Z

Save: /* Esercizio c.1 */

[[Media:20170529.jpg | link al compito]]

Ho caricato questa foto del compito intanto che non è ancora disponibile il pdf. Quando sarà disponibile sostituire con il link al pdf. --[[User:FedericoB|FedericoB]] ([[User talk:FedericoB|talk]]) 11:41, 15 June 2017 (CEST)

==Esercizio c.1==

se qualcuno può correggermi o confermare il rispetto delle regole concorrenziali, mi fa un grande piacere.
saluti

<syntaxhighlight lang="C">
Monitor rubaBandiera () {

condition oktochiama, oktopunteggio, oktopronto;

listnum [] = [1,2,3,4]
numeri[]
numeriChiamati[0...MAX-1]
studentiPronti = True;

punteggio [A] = 0;
punteggio [B] = 0;

procedure entry gioco() {

n=random(listnum);
numeri(n)=random(numeriChiamati);

if( studentiPronti == false)

oktochiama(numeri).wait() ;

studentiPronti(numeri) = false ;
oktopunteggio.signal();
}
procedure entry studente () {

while(studentiPronti(numeri))

oktochiama(numeri).signal();
}

procedure entry chiama () {

print(punteggio[A] ":" punteggio[B]);
if (studentiPronti(numeri))

oktopunteggio.wait()

if (allabadiera(A))
punteggio[A] ++;
else punteggio [B]++;
print(punteggio[A] ":" punteggio[B]);
studentiPronti(numeri) = true

pronto();

procedure entry pronto() {

if(punteggio[A] || punteggio[B] < 10)

return 0;
else return 1;
}}
</syntaxhighlight>

==Esercizio c.2==

==Esercizio g.1==

==Esercizio g.2==
#'''Un i-node di un file system tipo ext2 per un errore viene riportato un numero di link maggiore del reale. Cosa può succedere se si continua ad usare il file system? (perchè?) E se il numero di link errato fosse il contrario inferiore al reale cosa potrebbe succedere? (perchè?)
#'''Perchè è necessario usare spinlock in sistemi multiprocessore per implementare kernel di tipo simmetrico (SMP)?''' <br>Perchè la semplice disabilitazione degli interrupt non sarebbe sufficiente in caso di parallelismo reale a prevenire l'accesso a memoria condivisa in concorrenza. Bisogna perciò utilizzare strumenti come gli spinlock che grazie a istruzioni atomiche, per esempio la test-and-set, bloccano l'esecuzione di un processo fino al verificarsi di una condizione. Per evitare il busy wait si possono usare gli spinlock solo per rendere atomiche le istruzioni P e V di un semaforo in modo che la maggior parte del tempo di attesa per entrare in una sezione critica un processo lo passi in stato di wait invece che consumare inutilmente cicli di CPU.
#'''Perchè nei sistemi reali l'algoritmo di rimpiazzamento second chance (orologio) viene preferito a LRU sebbene il primo non sia a stack e il secondo sì?
#'''Perchè revocare un'autorizzazione espressa come capability è più difficile che revocare lo stesso diritto quando espresso come access control list?'''

Prova teorica 2017.05.29

2017-06-15T12:14:38Z

Save: /* Esercizio c.1 */

[[Media:20170529.jpg | link al compito]]

Ho caricato questa foto del compito intanto che non è ancora disponibile il pdf. Quando sarà disponibile sostituire con il link al pdf. --[[User:FedericoB|FedericoB]] ([[User talk:FedericoB|talk]]) 11:41, 15 June 2017 (CEST)

==Esercizio c.1==

se qualcuno può correggermi o confermare il rispetto delle regole concorrenziali, mi fa un grande piacere.
saluti

<syntaxhighlight lang="C">
Monitor rubaBandiera () {

condition oktochiama, oktopunteggio, oktopronto;

listnum [] = [1,2,3,4]
numeri[]
numeriChiamati[0...MAX-1]
studentiPronti = True;

punteggio [A] = 0;
punteggio [B] = 0;

procedure entry gioco() {

n=random(listnum);
numeri=random(numeriChiamati);

if( studentiPronti == false)

oktochiama(numeri).wait() ;

studentiPronti(numeri) = false ;
oktopunteggio.signal();
}
procedure entry studente () {

while(studentiPronti(numeri))

oktochiama(numeri).signal();
}

procedure entry chiama () {

print(punteggio[A] ":" punteggio[B]);
if (studentiPronti(numeri))

oktopunteggio.wait()

if (allabadiera(A))
punteggio[A] ++;
else punteggio [B]++;
print(punteggio[A] ":" punteggio[B]);
studentiPronti(numeri) = true

pronto();

procedure entry pronto() {

if(punteggio[A] || punteggio[B] < 10)

return 0;
else return 1;
}}
</syntaxhighlight>

==Esercizio c.2==

==Esercizio g.1==

==Esercizio g.2==
#'''Un i-node di un file system tipo ext2 per un errore viene riportato un numero di link maggiore del reale. Cosa può succedere se si continua ad usare il file system? (perchè?) E se il numero di link errato fosse il contrario inferiore al reale cosa potrebbe succedere? (perchè?)
#'''Perchè è necessario usare spinlock in sistemi multiprocessore per implementare kernel di tipo simmetrico (SMP)?''' <br>Perchè la semplice disabilitazione degli interrupt non sarebbe sufficiente in caso di parallelismo reale a prevenire l'accesso a memoria condivisa in concorrenza. Bisogna perciò utilizzare strumenti come gli spinlock che grazie a istruzioni atomiche, per esempio la test-and-set, bloccano l'esecuzione di un processo fino al verificarsi di una condizione. Per evitare il busy wait si possono usare gli spinlock solo per rendere atomiche le istruzioni P e V di un semaforo in modo che la maggior parte del tempo di attesa per entrare in una sezione critica un processo lo passi in stato di wait invece che consumare inutilmente cicli di CPU.
#'''Perchè nei sistemi reali l'algoritmo di rimpiazzamento second chance (orologio) viene preferito a LRU sebbene il primo non sia a stack e il secondo sì?
#'''Perchè revocare un'autorizzazione espressa come capability è più difficile che revocare lo stesso diritto quando espresso come access control list?'''

Prova teorica 2017.05.29

2017-06-15T12:13:15Z

Save: /* Esercizio c.1 */

[[Media:20170529.jpg | link al compito]]

Ho caricato questa foto del compito intanto che non è ancora disponibile il pdf. Quando sarà disponibile sostituire con il link al pdf. --[[User:FedericoB|FedericoB]] ([[User talk:FedericoB|talk]]) 11:41, 15 June 2017 (CEST)

==Esercizio c.1==

se qualcuno può correggermi o confermare il rispetto delle regole concorrenziali, mi fa un grande piacere.
saluti

Monitor rubaBandiera () {

condition oktochiama, oktopunteggio, oktopronto;

listnum [] = [1,2,3,4]
numeri[]
numeriChiamati[0...MAX-1]
studentiPronti = True;

punteggio [A] = 0;
punteggio [B] = 0;

procedure entry gioco() {

n=random(listnum);
numeri=random(numeriChiamati);

if( studentiPronti == false)

oktochiama(numeri).wait() ;

studentiPronti(numeri) = false ;
oktopunteggio.signal();
}
procedure entry studente () {

while(studentiPronti(numeri))

oktochiama(numeri).signal();
}

procedure entry chiama () {

print(punteggio[A] ":" punteggio[B]);
if (studentiPronti(numeri))

oktopunteggio.wait()

if (allabadiera(A))
punteggio[A] ++;
else punteggio [B]++;
print(punteggio[A] ":" punteggio[B]);
studentiPronti(numeri) = true

pronto();

procedure entry pronto() {

if(punteggio[A] || punteggio[B] < 10)

return 0;
else return 1;
}}

==Esercizio c.2==

==Esercizio g.1==

==Esercizio g.2==
#'''Un i-node di un file system tipo ext2 per un errore viene riportato un numero di link maggiore del reale. Cosa può succedere se si continua ad usare il file system? (perchè?) E se il numero di link errato fosse il contrario inferiore al reale cosa potrebbe succedere? (perchè?)
#'''Perchè è necessario usare spinlock in sistemi multiprocessore per implementare kernel di tipo simmetrico (SMP)?''' <br>Perchè la semplice disabilitazione degli interrupt non sarebbe sufficiente in caso di parallelismo reale a prevenire l'accesso a memoria condivisa in concorrenza. Bisogna perciò utilizzare strumenti come gli spinlock che grazie a istruzioni atomiche, per esempio la test-and-set, bloccano l'esecuzione di un processo fino al verificarsi di una condizione. Per evitare il busy wait si possono usare gli spinlock solo per rendere atomiche le istruzioni P e V di un semaforo in modo che la maggior parte del tempo di attesa per entrare in una sezione critica un processo lo passi in stato di wait invece che consumare inutilmente cicli di CPU.
#'''Perchè nei sistemi reali l'algoritmo di rimpiazzamento second chance (orologio) viene preferito a LRU sebbene il primo non sia a stack e il secondo sì?
#'''Perchè revocare un'autorizzazione espressa come capability è più difficile che revocare lo stesso diritto quando espresso come access control list?'''

Prova teorica 2014.07.16

2017-05-23T10:41:31Z

Save:

Testo: [http://www.cs.unibo.it/~renzo/so/compiti/2014.07.16.tot.pdf]

== Esercizio c.1 ==
===Soluzione di S.G===
<syntaxhighlight lang="C">
/*
* Esercizio c.1: scrivere il monitor mMbb che realizzi un meccanismo di un minmax bounded buffer.
* Dopo le prime MIN operazioni di scrittura, un minmax bounded buffer deve sempre avere almeno MIN elementi e mai piu' di MAX
* elementi (e' quindi limitato sia nell'ampiezza massima, sia nell'ampiezza minima).
* Le funzioni (procedure entry) read e write del minmax bounded buffer hanno gli stessi argomenti e valori di ritorno di quelle del
* producer/consumer o del bounded buffer ordinario.
*/
#define MIN
#define MAX
#define SIZE // con SIZE >= MAX

monitor mMbb{

generic_type bb[];
int front, rear, count;
condition R, W;

void mMbb(void){
bb = new generic_type[SIZE];
front = rear = count = 0;
}

procedure_entry generic_type read(){
while(count < MIN) // Controllo che il buffer abbia MIN elementi per poter leggere
R.wait();

generic_type ret = bb[rear];
count--;
rear = (rear + 1) % SIZE;
W.signal();
return ret;
}

procedure_entry write(generic_type c){
while(count >= MAX) // Controllo che il buffer non abbia MAX elementi per poter scrivere
W.wait();

bb[front] = c;
count++;
front = (front + 1) % SIZE;
R.signal();
}

}

</syntaxhighlight>
[[User:S.G|S.G]] ([[User talk:S.G|talk]]) 17:21, 2 December 2016 (CET)

Non è fifo. Perché? [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 07:43, 3 December 2016 (CET)

Nel caso in cui MIN vale 3 e arrivino tre processi lettori nel seguente ordine, L1, L2, L3, avremmo che la coda di R è la seguente:

R: L1, L2, L3

Ora arriva un processo scrittore S1, viene eseguito liberando un lettore (R.signal) cioè L1. A questo punto L1 riprende la sua esecuzione, riesegue il ciclo e rientra nello stato di attesa. Quindi ora la coda di R è la seguente:

R: L2, L3, L1

Si potrebbe risolvere il problema modificando le funzioni write e read nel seguente modo:

<syntaxhighlight lang="C">
procedure_entry generic_type read(){
if(count < MIN) // Controllo che il buffer abbia MIN elementi per poter leggere
R.wait();

generic_type ret = bb[rear];
count--;
rear = (rear + 1) % SIZE;
if(count < MAX)
W.signal();
return ret;
}

procedure_entry write(generic_type c){
if(count >= MAX) // Controllo che il buffer non abbia MAX elementi per poter scrivere
W.wait();

bb[front] = c;
count++;
front = (front + 1) % SIZE;
if(count > MIN)
R.signal();
}
</syntaxhighlight>
[[User:S.G|S.G]] ([[User talk:S.G|talk]]) 10:37, 3 December 2016 (CET)
===Soluzione di Stefano Zaniboni===
<source lang="c">
/*esercizio 1*/

monitor mMbb{
object[] buffer; //spazio di memorizzazione

final int MAXELEM; // numero massimo di elementi che ci possono essere nel buffer
final int MINELEM; //numero minimo di elementi --> numero di scritture minime

condition okW; // dove mi fermo se non posso scrivere
condition okR; // dove mi fermo se non posso leggere

int count; // elementi presenti nel buffer
int front; // contatore al elemento prodotto
int rear; // contatore al elemento consumato

mMbb(){
buffer = new Object[MAXELEM];
count = rear = front = 0;
}

procedure entry object read(){
if ((count < MINELEM)) //se il buffer e' pieno oppure non ci sono min elem chiamo la wait
okR.wait();
eltype val = buffer[rear]; // assegno al val l'elemento che ho letto e poi aggiorno rear
rear = ((rear + 1) % (MAXELEM -1 )); // aggiorno rear;
count--; // decremento count per dire che ho consumato un elemento
okW.signal(); // qui faccio signal sui produttori che adesso possono scrivere
return retval;
}
procedure entry void write(int val){
if (count == buffer.length) //se il buffer e' pieno mi fermo
okW.wait();
buffer[front] = val; //scrivo elemento
count++; //aggiorno i prodotti disponibili
front = ((front+1)%(MAXELEM - 1)); // aggiorno il contatore front a puntare nella prossima posizione

okR.signal();
}

}
</source>

===Soluzione di Sav===
<syntaxhighlight lang="C">

monitor mMbb {

condition oktowrite, oktoread
int waitingW = 0, waitingR = 0
buffer buffermM

procedure entry write(val) {

if ( buffermM.len()>= MAX)
waitingW++;
oktowrite.wait();
waitingW--;
buffermM.enqueue(val);
buffermM.enqueue(val);

while(buffermM.len()>= MIN)
oktoread.signal(); }

procedure entry read() {

if (buffermM.len()< MIN)
waitingR++;
oktoread.wait();
waitingR--;
buffermM.dequeue();
oktowrite.signal();
buffemM.dequeue();
oktowrite.signal();

}

</syntaxhighlight>
== Esercizio c.2 ==
===Soluzione di S.G===
<syntaxhighlight lang="C">
/*
* Esercizio c.2: Facendo uso di semafori scrivere la funzione rendezvous che consenta ai processi di sincronizzarsi secondo le
* seguenti specifiche:
* – Ogni processo indica come parametro della funzione rendezvous con quanti altri processi vuole sincronizzarsi.
* – M processi che chiamano la rendezvous con parametro N rimangono bloccati se M<N.
* – Quando l'N-mo processo richiama la rendezvous specificando N come parametro, lui e gli N-1 sospesi devono proseguire
* nelle propria esecuzione
*/

struct S {
Semaphore sem;
int N; // parametro della funzione rendezvous con quanti altri processi vuole sincronizzarsi
int I; // Contatore dei processi che richiamano rendezvous con paramentro N
}

List<S> listS = new List[]; // Lista di possibili semafori

Semaphore mutex = new Semaphore(1); // Variabile che consente la mutua esclusione

rendevouz(int n){
mutex.P(); // Ottengo la mutua esclusione

find = FALSE;
for(s in listS){ // Cerco il semaforo nella lista
if(s.N == n){
find = TRUE;
break;
}
}
if(find == FALSE){ // se non è presente nella lista lo creo
struct S s;
s.sem = new semaphore(0);
s.N = n;
s.I = 0;
listS.insert(s);
}

s.I++;
if(s.I == s.N){ // Quando l'N-mo processo richiama la rendezvous specificando N come parametro
while(s.I--) // lui e gli N-1 sospesi devono proseguire nelle propria esecuzione
s.sem.V();
}
else if(s.I < s.N){ // M processi che chiamano la rendezvous con parametro N rimangono bloccati se M<N
s.sem.P();
}

mutex.V(); // Rilascio la mutua esclusione
}
</syntaxhighlight>
Ho qualche dubbio su questa soluzione, riguardo la linea presente l'istruzione s.sem.P(), il processo viene immediatamente bloccato? Se si dovrei rilasciare la mutua esclusione prima quindi? [[User:S.G|S.G]] ([[User talk:S.G|talk]]) 16:43, 3 December 2016 (CET)

Si, la mutua esclusione va, in linea di principio, sempre rilasaciata prima di un' operazione P() poichè il processo che la chiama potrebbe bloccarsi tenendo con se la mutua esclusione e causando quindi deadlock.--[[User:FedericoP|FedericoP]] ([[User talk:FedericoP|talk]]) 10:37, 15 January 2017 (CET)
===Soluzione di MV===
<source lang="c">
// ------------------------- SOLUZIONE DI MV -------------------------

void rendezvous(int N)
{
struct S { Semaphore sem; int N; int M };

static List<struct S> L = new List<struct S>();
static Semaphore mutex = new Semaphore(1);

if(N <= 1) // se N==1 significa che non vuole sincronizzarsi
return; // se N<1 non ha senso => esce dalla funzione

bool trovato = false;
mutex.P(); // prende la mutua esclusione per evitare incoerenze
// scorre la lista in cerca di un semaforo per N
for(List<struct S> el = L.head(); !L.last(el) && !trovato; el = L.next(el) )
if(el.content.N == N) // se esiste
{
trovato = true;
if(el.content.M == N-1) // se è l'N-esimo processo
{
while(el.content.M) // sblocca tutti gli altri
{
el.content.sem.V();
el.content.M--;
}
mutex.V();
}
else // altrimenti si mette in attesa
{
el.content.M++;
mutex.V();
el.content.sem.P();
}
break;
}

if(!trovato) // se non esiste lo crea
{
// NB: ho ancora la mutua esclusione
struct S s;
s.N = N;
s.M = 1;
s.sem = new Semaphore(0);
L.insert_tail(S) // inserisce nella lista (in coda)

mutex.V():
// si mette in attesa sul semaforo appena creato (NB: N!=1)
L.tail().content.sem.P();
}
}

/* NOTA: gli elementi della lista non vengono deallocati una volta liberato
il semaforo; questo perchè è ancora possibile una race condition (rara)
nel caso in cui un processo P1 stia per inserirsi su un semaforo già esistente
(ha appena fatto mutex.V() ) e un altro P2 riesca ad entrare nel ciclo e
liberare tutti => P2 effettua una V in più e P1 esce subito dalla P
*/
</source>

===Soluzione di Alexp===
<source lang="c">
List<Queue<Semaphore>> waiting; //Lista di code di semafori
Semaphore mutex = 1; //Semaforo per modificare la lista delle code

void rendezvous(int N){
if(N >= 2){
//semaforo da accodare(e su cui si dovrà bloccare il thread nel caso waiting[N].size() < N)
Semaphore s = 0;
int i;
//entriamo nella critical section per modificare una struttura condivisa
mutex.P();
//se il chiamante non è l'N-esimo thread
if(waiting[N].size()+1 < N){
//accodiamo il semaforo nel caso non ci siano esattamente N thread con cui sincronizzarsi
waiting[N].enqueue(s);
//usciamo dalla critical section per non causare deadlock
mutex.V();
//fermiamo il thread sul semaforo accodato prima, nel caso in cui debba aspettare
//questo thread verrà risvegliato dall'N-esimo thread che si sincronizzerà
s.P();
}
//se il thread chiamante è proprio l'N-esimo(quindi dovrà sbloccare tutti)
else{
//per ogni thread accodato sulla coda in cui si sincronizzano N thread
/*
(in realtà nella coda ci sono N-1 semafori dei thread fermi
mentre il thread che entra in questo ramo else sarà l'N-esimo)
*/
for(i = 0; i < N-1; i++){
//togliamo dalla coda il semaforo e risvegliamo il thread che lo aspettava
waiting[N].dequeue().V();
}
//struttura condivisa modificata, usciamo dalla critical section
mutex.V();
}
}
}
</source>

Prova teorica 2014.09.24

2017-05-23T09:10:08Z

Save:

Testo: [http://www.cs.unibo.it/~renzo/so/compiti/2014.09.24.tot.pdf]

=== Esercizio c.1 ===

<syntaxhighlight lang="C">
/*
* Esercizio c.1: Scrivere un monitor vBB che realizzi un bounded buffer a dimensione variabile.
* Le procedure entry da implementare sono read, write e resize. Read e write hanno gli stessi parametri del BB ordinario.
* La funzione resize ha come parametro un numero intero positivo che rappresenta la nuova dimensione del buffer espressa in numero
* di elementi. Inizialmente il bounded buffer ha dimensione DEFAULTSIZE. Se la dimensione viene incrementata I processi
* eventualmente in attesa di scrivere devono poter inserire I loro elementi nel buffer fino a che e' consentito della nuova dimensione.
* Se la dimensione diminuisce, nuovi scrittori potranno inserire elementi nel buffer solo quando sara' possibile farlo in modo coerente
* con il nuovo numero massimo di elementi.
*/
#define DEFAULTSIZE

monitor vbb{
generic_type bb[];
int i, size;
conditions W, R;

void vbb(void){
bb = new generic_type[DEFAULTSIZE];
i = 0;
size = DEFAULTSIZE;
}

procedure entry void write(generic_type val){
if(i == size){ // Il buffer è completamente pieno
W.wait(); // Metto in attesa il processo
}
// Il buffer non è pieno, scrivo
bb[i] = val;
i++;
R.signal();
}

procedure entry generic_type read(void){
generic_type retval;
if(i == 0){ // Il buffer è vuoto
R.wait(); // Metto in attesa il processo
}
// Il buffer non è vuoto, leggo
i--;
retval = bb[i];
W.signal(); // Riattivo uno scrittore in coda
return retval;
}

procedure entry void resize(unsigned int n){
int old_size, j;
old_size = size;
size = n;
newbb = new generic_type[n];

if(n > old_size){ // Se la nuova dim. è maggiore di quella vecchia
int ndiff = n - old_size; // Numero di celle libere su cui scrivere

for(j = 0; j < old_size; j++) // Copia gli elementi di bb nel nuovo vettore
newbb[j] = bb[j];
bb = newbb;

for(j = 0; j < ndiff; j++) // allora più scrittori possono scrivere perchè vi sono celle libere
W.signal();
}
else{ // Se la nuova dim. è minore o uguale a quella vecchia

for(j = 0; j < n; j++) // Copia gli elementi di bb nel nuovo vettore
newbb[j] = bb[j];
bb = newbb;

if(i >= n){ // se il buffer è comunque completamente pieno
if(i > n)
i = n;
R.signal(); // allora un lettore può leggere
}
else{ // se il buffer non è ancora pieno
W.signal(); // allora uno scrittore può scrivere
}
}
}

}
</syntaxhighlight>
[[User:S.G|S.G]] ([[User talk:S.G|talk]]) 14:18, 21 November 2016 (CET)

Questo è un bounded stack! non un bounded buffer (che deve essere FIFO, se no c'e' starvation!).
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 19:17, 21 November 2016 (CET)
=== Esercizio c.1 mia soluzione ===
<syntaxhighlight lang="C">
#define DEFAULTSIZE

monitor vBB {

condition oktowrite, oktoread
int waintingW // scrittori in attesa
int waintingR // lettori in attesa
buffer buffer = defaultsize;
procedure entry write {

if (bufferlen() >= defaultsize)
waitingW ++;
okowrite.wait();
waitingW++;
buffer.enqueue(val);
oktoread.signal();
buffer.enqueue(val);
}

procedure entry read () {

if (buffer.len() == 0)
waitingR++;
oktoread.wait();
waitingR--;
buffer.dequeue();
buffer.dequeue();
oktowrite.signal();
}

procedure entry resize (n) {

buffer=(int*)realloc(n*sizeof(int);
while (waitingW>0)
oktowrite.signal()
}
}

</syntaxhighlight>

==Esercizio 2==
Appunti:
Si può usare semplicemente il message passing a coda ma inserire in uno stack i messaggi che arrivano.
Nella recv si può automandarsi un messaggio con un tag particolare per sapere quando abbiamo letto tutti i messaggi.
--[[User:FedericoB|FedericoB]] ([[User talk:FedericoB|talk]]) 13:49, 9 May 2017 (CEST)

Prova teorica 2015.01.20

2017-05-23T08:09:13Z

Save:

Testo: [http://www.cs.unibo.it/~renzo/so/compiti/2015.01.20.tot.pdf]

== Esercizio c.1 ==
===Soluzione di S.G===
<syntaxhighlight lang="C">
/*
* Esercizio c.1: Scrivere il monitor lwlrbb. Il monitor deve implementare le seguenti procedure entry:
* void write(generic_type val);
* generic_type read(void);
* Il lwlrbb si comporta come un bounded buffer di MAX elementi che coordina l'attivita' di numerosi processi
* produttori/scrittori e numerosi lettori/consumatori. lwlrbb ammette un numero massimo (sempre MAX) di lettori
* e scrittori in attesa. Se il buffer e' vuoto e ci sono piu' gia' MAX lettori in attesa, il lettore che e' in
* attesa da piu' tempo esce resituendo NULL. In ugual modo se il buffer e' completamente pieno e ci sono gia' MAX
* scrittori che attendono di scrivere viene perduto il valore che da piu' tempo nel buffer attende di venir letto,
* il primo processo in attesa di scrivere puo' cosi' scrivere il suo elemento nel buffer e sbloccarsi.
*/
#define MAX

monitor lwlrbb{
generic_type bb[];
int count, rear, front, nw, nr;
bool exitNull;
conditions lw, lr;

void lwlrbb(void){
bb = new generic_type[MAX];
exitNull = FALSE;
rear = count = front = nw = nr = 0;
}

procedure entry void write(generic_type val){
if(count == MAX){ // Il buffer è completamente pieno
if(nw == MAX){ // ci sono già MAX scrittori che attendono di scrivere
rear = (rear + 1) % MAX; // Salto l'elemento da leggere da più tempo
count--;
lw.signal(); // il primo processo in attesa di scrivere puo' sbloccarsi.
}
nw++;
lw.wait();
nw--;
}
bb[front] = val; // Il buffer non è pieno, scrivo
count++;
front = (front + 1) % MAX;
lr.signal();
}

procedure entry generic_type read(void){
generic_type retval;
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
lr.signal();
}
nr++; // incremento il contatore dei lettori in coda
lr.wait(); // metto in attesa il lettore
// Riprendo l'esecuzione da dove era stata interrotta
nr--; // decremento il contatore dei lettori in coda
if(exitNull){ // Controllo se è una richiesta di uscita forzata
exitNull = FALSE;
return NULL;
}
}
count--; // Il buffer non è vuoto, leggo
retval = bb[rear];
rear = (rear + 1) % MAX;
lw.signal();
}

}
</syntaxhighlight>

[[User:S.G|S.G]] ([[User talk:S.G|talk]]) 14:39, 18 November 2016 (CET)<br>
Ho scritto una possibile soluzione dell'esercizio c.1. Iniziare qui una discussione

'''è uno stack! bounded buffer deve implementare una coda.''' [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 19:29, 21 November 2016 (CET)

Ho implementato la coda. [[User:S.G|S.G]] ([[User talk:S.G|talk]]) 10:12, 22 November 2016 (CET)
----
===Soluzione di BAGG===
<source lang="c">
#define MAX 42

monitor lwlrbb {
generic_type bb[] ;
int count, front, rear ; /* rispettivamente: numero elementi, dove scrivere nel buffer, dove leggere nel buffer */
int nw, nr ; /* rispettivamente numero di writer e reader */
bool exit ; /* server ai reader per sapere se devono ritornare NULL al loro rientro nel monitor */
condition canr, canw ;

lwlrbb(void) {
bb = new generic_type[MAX] ;
count = front = rear = nw = nr = exit = 0 ;
}

entry void write(generic_type val) {
if(count == MAX) { /* se count è MAX non si può scrivere */
if(nw == MAX) { /* se la coda è piena devo fare spazio */
rear = (rear + 1)%MAX ; /* rear indica il più vecchio elemento ancora da leggere, lo incremento --> salto l'elemento */
count -= 1 ;
nw += 1 ; /* incremento prima perchè anche se la coda è piena ora dopo la signal ci sarà un posto... */
canw.signal() ; /* ora il primo che aspettava può scrivere --> lo sveglio */
canw.wait() ;
nw -= 1 ;
} else { /* se la coda non è piena devo comunque aspettare... */
nw += 1 ;
canw.wait() ;
nw -=1 ;
}
}
bb[front] = val ;
front = (front + 1)%MAX ;
count += 1 ;
canr.signal() ; /* potrebbe esserci un reader che aspetta --> segnalo che ho scritto e si può leggere */
}

entry generic_type read(void) {
if(count == 0) { /* se non c'è nulla da leggere allora devo aspettare */
if(nr == MAX) { /* se la coda è piena setto exit, che i reader controllano per sapere se sono stati svegliati per ritornare NULL */
exit = 1 ;
canr.signal() ; /* sveglio il condannato... */
} nr += 1 ; /* mi accodo... */
canr.wait() ;
nr -= 1 ;
if(exit) { /* se sono il condannato resetto la variabile ed esco... */
exit = 0 ;
return NULL ;
}
}
generic_type r = bb[rear] ;
rear = (rear + 1)%MAX ;
count -= 1 ;
canw.signal() ; /* ho letto, quindi si è liberato un posto e almeno un writer può scrivere... */
return r ;
}
}
</source>
===Soluzione di FedericoB===
Pseudocodice simil python
<source lang="Python">
monitor lwlrbb
queue buf
contion ok2read, ok2write; int wr=0; int ww=0

proc entry write(val)
if (buf.len()) >= BUFSIZE):
if (ww>=max):
ok2write.signal()
else:
w++
ok2write.wait()
w--
if (buf.len() >= BUFSIZE):
buf.deque()
buf.enqueue(val)
ok2read.signal()

proc entry read()
if (buf.len()==0):
if (wr>=max):
//il primo lettore deve usire
ok2read.signal()
wr++
ok2read.wait()
wr--
if (buf.len()>0):
retval = buf.dequeue()
ok2write.signal()

</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 ==
===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
attivazione di dualshift era il bit meno significativo di a.
es. se a vale 6 e b vale 4 dopo la chiamata di dualshift(a,b) a vale 3 e b 2. Se a vale 5 e b 6 dopo la chiamata dualshift (a,b) a vale 2
e b vale 131 (128+3).
La funzione dualshift puo' essere usata al posto della test&set per la sincronizzazione fra processi? Dimostrare la risposta.
b) Si consideri ora la funzione andor(a,b) che opera su due opera su due parametri di tipo booleano passati per indirizzo e cosi'
definita:
andor(a,b)=<c=a or b; b=a and b; a=c>
Puo' la funzione andor essere usata al posto della test&set per la sincronizzazione fra processi? Dimostrare la risposta.
Si ricorda che le operazioni di assegnazione di valori costanti a variabili vengono considerati atomici.

Svolgimento

a) Non è possibile utilizzare la funzione atomica dualshift(a,b) in quanto per la definizione di test&set(a,b)
<syntaxhighlight lang="C">
test&set(a,b){
a = b;
b = X; // Dove X è un valore costante
}
</syntaxhighlight>
La funzione dualshift dovrebbe memorizzare (in qualche modo) il valore precedente di a (o b), e successivamente settare a (o b) ad un valore costante. Questo non accade perchè la stessa funzione divide per 2 i valori di a e b ogni volta che viene richiamata (caso particolare in cui venga copiato il bit meno significativo di a nel bit più significativo di b). Quindi è impossibile soddisfare la richiesta.

b) La funzione andor(a,b) può essere utilizzata al posto della test&set per la sincronizzazione fra processi.
Dimostrazione.
La funzione andor(a,b) è definita come segue:

<syntaxhighlight lang="C">
andor(a, b){
c = a | b;
b = b & a;
a = c;
}
</syntaxhighlight>
Posto a = 0, non avremo altro che:

<syntaxhighlight lang="C">
andor(a, b){
c = b;
b = 0;
a = c;
}
</syntaxhighlight>

Quindi la funzione andor, non è altro che una semplice test&set.

<syntaxhighlight lang="C">
a = 0;
b = 1;

Process P {
do{
andor(a, b);
} while(!a);
//critical section
b = 1;
// non-critical section
}
</syntaxhighlight>
[[User:S.G|S.G]] ([[User talk:S.G|talk]]) 14:39, 18 November 2016 (CET)<br>
Ho scritto una possibile soluzione dell'esercizio c.2. Iniziare qui una discussione

'''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>
----
===Soluzione di FedericoB===
<source lang="text">
dualshift(a,b) |xxxxxxxx|yyyyyyyy| -> |0xxxxxxx|xyyyyyyy|
G=1
MUTEXIN
do:
L=0
dualshift(G,L)
while L==0;
MUTEXOUT
G=1
</source>

== Esercizio g.1 ==

a) Sia data la seguente stringa di riferimenti: 123451234123121.
mostrare il comportamento degli algoritmi MIN e LRU quando operano su una memoria di 3 frame.
b) Data una memoria di 4 frame contenente la pagina 4 nel frame 1, la pagina 3 nel frame 2, la pagina 2 nel frame 3 e infine la
pagina 1 nel frame 4. Mostrare una stringa di riferimenti di un programma che usi 5 pagine (esiste la pagina 5 non ancora mappata in
memoria oltre alle 4 cariate nei frame) e che consenta alla fine dell'esecuzione di avere tutte le pagine nel frame di indice
corrispondente. La pagina 1 nel frame 1, la pagina 2 nel frame 2 e cosi' via.

Esecuzione algoritmo MIN
<syntaxhighlight lang="C">
-------------------------------------------------------------
| 1 | 2 | 3 | 4 | 5 | 1 | 2 | 3 | 4 | 1 | 2 | 3 | 1 | 2 | 1 |
-------------------------------------------------------------

-------------------------------------------------------------
| 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
-------------------------------------------------------------
| | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 |
-------------------------------------------------------------
| | | 3 | 4 | 5 | 5 | 5 | 3 | 4 | 4 | 4 | 3 | 3 | 3 | 3 |
-------------------------------------------------------------
</syntaxhighlight>

Esecuzione algoritmo LRU
<syntaxhighlight lang="C">
-------------------------------------------------------------
| 1 | 2 | 3 | 4 | 5 | 1 | 2 | 3 | 4 | 1 | 2 | 3 | 1 | 2 | 1 |
-------------------------------------------------------------

-------------------------------------------------------------
| 1 | 1 | 1 | 4 | 4 | 4 | 2 | 2 | 2 | 1 | 1 | 1 | 1 | 1 | 1 |
-------------------------------------------------------------
| | 2 | 2 | 2 | 5 | 5 | 5 | 3 | 3 | 3 | 2 | 2 | 2 | 2 | 2 |
-------------------------------------------------------------
| | | 3 | 3 | 3 | 1 | 1 | 1 | 4 | 4 | 4 | 3 | 3 | 3 | 3 |
-------------------------------------------------------------
</syntaxhighlight>

Una possibile sequenza utilizzando l'algoritmo con sostituzione FIFO
<syntaxhighlight lang="C">
-------------------------------------------------------------
| 4 | 3 | 2 | 1 | 5 | 6 | 7 | 8 | 9 | 0 | 1 | 2 | 3 | 4 | 5 |
-------------------------------------------------------------
</syntaxhighlight>
[[User:S.G|S.G]] ([[User talk:S.G|talk]]) 12:19, 19 November 2016 (CET)<br>
Ho scritto una possibile soluzione dell'esercizio g.1. Iniziare qui una discussione

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

== Esercizio g.2 ==

a) Se un sistema ha una RAM molto ampia puo' non essere utile usare la memoria virtuale. In questo caso ha senso egualmente
usare la paginazione di memoria? Perche'?

b) Perche' i metodi di sincronizzazione tipo test&set (detti anche spinlock) assumono grande rilevanza nella scrittura di sistemi
operativi multiprocessore?

c) Confrontare gli alogritmi di scheduling roud robin e a priorita' statica. Indicare in quali casi sono da usare algoritmi di tipo round
robin e quando quelli a priorita' statica.

Svolgimento

a) Paginazione è un metodo di gestione della memoria che permette che lo spazio degli indirizzi fisici di un processo
non sia contiguo, inoltre ha i seguenti vantaggi:
- riduce il fenomeno della frammentazione interna
- minimizza (elimina) il fenomeno della frammentazione esterna

b) Perchè permette di risolve il problema della sezione critica in modo relativamente semplice. Infatti l'istruzione
test&set è eseguita atomicamente, cioè come un'unita non soggetta a interruzzioni; quindi se si eseguono contemporaneamente
due istruzioni test&set, ciascuna su processori diversi, queste vengono eseguite in modo sequenziale in un ordine arbitrario.

c) Scheduling a priorità statica associa una priorità a ogni processo e si assegna la CPU
al processo con priorità più alta; i processi con priorità uguali si ordinano secondo una politica
FCFS. Questo algoritmo può essere sia con prelazione sia senza prelazione, inoltre soffre dell'attesa
indefinita (starvation). Infatti un flusso costante di processi con priorità maggiore può impedire a
un processo con priorità più bassa di accedere alla CPU. E' possibile utilizzare questo algoritmo quando
alcuni processi hanno più importanza di altri. es: nel caso di sistemi multimediali, come una smart TV, il
processo di riproduzione video è più importante rispetto ad un processo gestore di posta, altrimenti il flusso video
potrebbe essere discontinuo.

Scheduling circolare (round-robin) è un algoritmo con prelazione in cui ogni processo viene eseguito al massimo
per un quanto di tempo. E' bene che il quanto di tempo sia maggiore del tempo necessario al cambio di contesto.
Questo algoritmo a differenza dello scheduling a priorità statica non soffre di starvation. E' possibile utilizzare
questo algoritmo in sistemi in cui si pretende un finto parallelismo. es: nel caso in cui più studenti accedano ad
una determinata macchina del laboratorio.

[[User:S.G|S.G]] ([[User talk:S.G|talk]]) 11:24, 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)

ProvaTeorica 2012.02.09

2014-07-14T12:32:29Z

Save:

Esercizio 1
<syntaxhighlight lang="C">
/*
Esercizio 1: Il monitor seq da implementare deve fornire due procedure entry:
procedure entry void enter(void);
procedure entry void exit(void);
I processi chiamano i servizi di seq come segue:
….
seq.enter();
// codice controllato da seq
seq.exit();
….
Tutti i processi che ne facciano rischiesta possono entrare nel codice controllato da seq contemporaneamente (questa
NON e' una sezione critica!). Exit deve garantire che i processi escano dal codice controllato tutti insieme. Per
esempio se tre processi a,b e c chiamano seq.enter ogni processo non potra' completare la exit se prima tutti gli altri
due non hanno chiamato la exit. Se nel frattempo altri processi dovessero chiamare la seq.enter occorrera' attendere
anche questi ultimi.
*/

monitor seq
{
int processi=0;
condition oktoexit;

procedure entry enter()
{
processi++
}

procedure entry exit()
{
processi--
oktoexit.signal();
while(processi!=0)
{
oktoexit.wait();
}

}
}
</syntaxhighlight>
-stefano92

<syntaxhighlight lang="C">

monitor seq
{
int processi=0;
int inattesa=0 ;
condition oktoexit;

procedure entry enter()
{
processi++
}

procedure entry exit()
{

processi-- ;

while(processi!=0)
{
inattesa++ ;
oktoexit.wait();
inattesa--;
}

oktoexit.signal();
}
}

Save

</syntaxhighlight>

ProvaTeorica 2012.02.09

2014-07-14T12:30:47Z

Save:

Esercizio 1
<syntaxhighlight lang="C">
/*
Esercizio 1: Il monitor seq da implementare deve fornire due procedure entry:
procedure entry void enter(void);
procedure entry void exit(void);
I processi chiamano i servizi di seq come segue:
….
seq.enter();
// codice controllato da seq
seq.exit();
….
Tutti i processi che ne facciano rischiesta possono entrare nel codice controllato da seq contemporaneamente (questa
NON e' una sezione critica!). Exit deve garantire che i processi escano dal codice controllato tutti insieme. Per
esempio se tre processi a,b e c chiamano seq.enter ogni processo non potra' completare la exit se prima tutti gli altri
due non hanno chiamato la exit. Se nel frattempo altri processi dovessero chiamare la seq.enter occorrera' attendere
anche questi ultimi.
*/

monitor seq
{
int processi=0;
condition oktoexit;

procedure entry enter()
{
processi++
}

procedure entry exit()
{
processi--
oktoexit.signal();
while(processi!=0)
{
oktoexit.wait();
}

}
}
</syntaxhighlight>
-stefano92

<syntaxhighlight lang="C">

monitor seq
{
int processi=0;
int inattesa=0 ;
condition oktoexit;

procedure entry enter()
{
processi++
}

procedure entry exit()
{

processi-- ;

while(processi!=0)
{
inattesa++ ;
oktoexit.wait();
inattesa=0;
}

oktoexit.signal();
}
}

Save

</syntaxhighlight>

ProvaTeorica 2012.05.24

2014-06-01T18:05:38Z

Save:

<h1>http://www.cs.unibo.it/~renzo/so/compiti/2012-05-24.tot.pdf</h1>

<syntaxhighlight lang="C">
monitor santuario
{
#define ANDATA 0
#define RITORNO 1
condition oktoenterponte, oktoexitponte ;
int waiting, crossing, medita ;

procedure entry enterponte(ANDATA)
{

if ( crssing(ritorno) > = 0 || crossing(ANDATA) > maxSantuario || waiting (RITORNO)>0 ) # per evitare deadlock
# deve essere maxSantuario >= maxPonte
waiting (ANDATA)++ ; # crossing(ANDATA) >= maxSantuario
oktoenterponte(ANDATA).wait();
waiting(ANDATA)-- ;
crossing(ANDATA)++ ;
}

procedure entry exitponte(ANDATA) # Entra nel santuario
{
if ( medita == maxSantuario )
oktoexitponte(ANDATA).wait() ;
crossing(ANDATA)--;
medita++ ;
if (waiting(RITORNO) > 0 ) && (crossing(ANDATA)==0)
oktoenterponte(RITORNO).signal();
oktoenterponte(ANDATA).signal();
}

rocedure entry enterponte(RITORNO) # Esci dal santuario
{
if (crossing(ANDATA)>0 || crossing(RTORNO) >= maxPonte)
wiiting(RITORNO)++;
oktoenterponte(RITORNO).wait();
waiting(RITORNO)--;
medita--;
crossing(RITORNO)++;
}

procedure entry exitponte(RITORNO)
{
crossing(RITORNO)--;
if (waiting(RITORNO)>0)
oktoexitponte(RITORNO).signal()
oktoenterponte(ANDATA).signal() ;
}
}

/* Correggetemi se sbaglio.

STARVATION : non l'ho individuata.
Io penso che se al santuario recitassero tutti il rosario e confessassero molti peccati, allora si.
DEADLOCK : se la portata del ponte era piu' grande della portata del santuario si aveva deadlock.
L'ho eliminato mettendo in wait se crossing(ANDATA) > maxSantuario
*/
save
</syntaxhighlight>

<syntaxhighlight lang="C">
monitor santuario
{
Go = 0; // andare al santuario
Back = 1; // tornare indietro
condition ok[2]; // 2 condizioni
crossing[2] = {0, 0}; // numero di persone sul ponte
visiting = 0; // numero di persone nel santuario
waiting[2] = {0, 0}; // numero di persone in attesa

procedure entry entraponte(dir)
{
/* Mi blocco se:
- il numero di persone sul ponte ha raggiunto il massimo; oppure
- la direzione e' il santuario e il numero di visitatori
(compresi quelli che stanno raggiungendo il santuario) ha raggiunto il massimo; oppure
- qualcuno sta attraversando il ponte in direzione opposta; oppure
- qualcuno sta attendendo di attraversare nel senso opposto */
if (crossing[dir] == MAXPONTE ||
(dir == Go && visiting + crossing[dir] == MAXSANTUARIO) ||
crossing[1 - dir] > 0 ||
waiting[1 - dir] > 0)
{
waiting[dir]++;
ok[dir].wait();
waiting[dir]--;
}
crossing[dir]++;

if (dir == Back)
visiting--;
}

procedure entry esciponte(dir)
{
crossing[dir]--;

if (dir == Go)
visiting++;

// [Case 1] Nessuno sta attraversando il ponte
if (crossing[dir] == 0)
ok[1 - dir].signal();
// [Case 2] Qualcuno sta attraversando il ponte
else
ok[dir].signal();
}
}
</syntaxhighlight>
-TomOgn

<syntaxhighlight lang="C">
monitor santuario{
#define ANDATA 0
#define RITORNO 1

int waiting[2];
int crossing[2];
condition oktoenter[2];
int count; /* persone dentro al santuario */

procedure entry entraponte(int dir){
if (dir == ANDATA){
if (crossing[1-dir] > 0 || crossing[dir] >= MAXPONTE || cout+crossing[dir] >= MAXSANTUARIO){
waiting[dir]++;
oktoenter[dir].wait();
waiting[dir]--;
}
}
else {
if (crossing[1-dir] > 0 || crossing[dir] >= MAXPONTE){
waiting[dir]++;
oktoenter[dir].wait();
waiting[dir]--;
}
}
crossing[dir]++;
if ((crossing[dir]+count < MAXSANTUARIO) && crossing[dir] < MAXPONTE)
oktoenter[dir].signal();
}

procedure entry esciponte(int dir){
crossing[dir]--;
if (dir == ANDATA){
count++;
if (count+crossing[dir] < MAXSANTUARIO) /* voi che siete in attesa andate sul ponte */
oktoenter[dir].signal();
}
else
count--;

if (crossing[dir] == 0)
oktoenter[1-dir].signal();
}
}
</syntaxhighlight>
Gabriele & Giulia (se non va colpa di Gabriele)

<syntaxhighlight lang="C">

monitor santuario{
int CurrentDir /* 0 = arriving , 1 = leaving */
int crossing
condition oktoenter
condition oktoleave
//queue enter
//queue ponte
//queue leave
int fidelis /* fedeli nel tempio */

procedure entry entraponte(CrossingDir){
if(CrossingDir != CurrentDir){
if(CrossingDir == 0){
//enter.enqueue()
oktoenter.wait()
//enter.dequeue()
}
if(CrossingDir == 1){
//leave.enqueue()
oktoleave.wait()
//leave.dequeue()
}
}
if(CrossingDir == 0){
if(fidelis == MAXSANTUARIO || crossing == MAXPONTE){
//ponte.enqueue()
oktoenter.wait()
//ponte.dequeue()
}
fidelis++
crossing++
}
if(CrossingDir == 1){
if(crossing == MAXPONTE){
//ponte.enqueue()
oktoleave.wait()
//ponte.dequeue()
}
fidelis--
crossing++
}
}

precedure entry esciponte(CrossingDir){
crossing--
if(crossing == 0){
if(CrossingDir == 0){
if(fidelis < MAXSANTUARIO /*&& !enter.isempty()*/){
oktoenter.signal()
}
else{
CurrentDir = 1 - CurrentDir
oktoleave.signal()
}
}
else{
CurrentDir = 1 - CurrentDir
oktoenter.signal()
}
}

}

santuario{
crossing = 0
CurrentDir = 0
fidelis = 0
}
}
</syntaxhighlight>
Fede & Mirko

<syntaxhighlight lang="C">

monitor santuario {
condition okpassa; // vai sul ponte secondo metodo FIFO
int turn=2; // turno di attraversamento
int visitatori[2]; // contatori andata ritorno
visitatori[0]=0;
visitatori[1]=0;
int fedeli=0;
int i=0;
Queue q; // coda dei visitatori in attesa

procedure entry entraponte(dir){
/* se il turno è della direzione opposta o
i visitatori in transito sono MAXPONTE o
la coda non è vuota aspetta */
if( (dir==0 && fedeli==MAXSANTUARIO ) || turn==(1-dir) || visitatori[dir]==MAXPONTE || !q.empty()){
q.enqueue(dir); // inserisci in coda
okpassa.wait(); // aspetta
if( q.head()==dir && (visitatori[dir] + i) < (MAXPONTE - 1) ){ // questa condizione
i++;
q.dequeue(); // mi serve per far passare
okpassa.signal(); // MAXPONTE visitatori nella direzione
} // in attesa quando nella direzione opposta
i=0; // i visitatori in transito erano N
}
turn=dir; // setto il turno della direzione
visitatori[dir]++; //incremento visitatori in transito
if(dir==0){fedeli++;}
if(dir==1){fedeli--;}
}

procedure entry esciponte(dir){
visitatore[dir]--; //decremento visitatori in transito
/* se il primo visitatore in attesa va nella stessa direzione
di chi è uscito può entrare sul ponte poichè questo
si verifica solo se il visitatore uscito era il numero N
o il visitatore che esce è l'ultimo fa passare il primo in attesa
che sarà sicuramente della direzione opposta */
primo = (dir == 0 && fedeli < MAXSANTUARIO) && ( q.head()==0 || visitatori[0]==0 ))
secondo = (dir == 1 && (q.head()==0 || visitatori[1]==0 )

if(primo || secondo){
if(visitatore[dir]==0){
turn=2; // ponte vuoto
}
q.dequeue();
okpassa.signal(); // causa il passaggio sul ponte
// del primo visitatore in attesa
// (secondo una politica FIFO)
}

}

</syntaxhighlight>
Alessandro

<syntaxhighlight lang="C">
#define ANDARA 0;
#define RITORNO 1;
monitor santuario{
int cross;
condition oktocross[2];
int fidelis;
entraponte(dir){
if( cross != 0 || (dir == 0 && MAXSANTUARIO == fidelis)){
wait[dir]++;
oktocross[dir].wait();
wait[dir]--;
}
cross++;
if(dir == 0){
fidelis++;
if(cross < MAXPONTE && MAXSANTUARIO > fidelis){
oktocross[dir].signal;
}
}else{
fidelis--;
if(cross < MAXPONTE){
oktocross[dir].signal;
}
}
}
esciponte(dir){
cross--;
if(cross == 0 && MAXSANTUARIO == fidelis){
oktocross[RITORNO].signal();
}else if(cross == 0 && wait[1-dir]){
oktocross[1-dir].signal();
}else if(cross == 0){
oktocross[dir].signal();
}
}
}
</syntaxhighlight>
-Midolo

ProvaTeorica 2012.05.24

2014-06-01T18:04:52Z

Save:

<h1>http://www.cs.unibo.it/~renzo/so/compiti/2012-05-24.tot.pdf</h1>

<syntaxhighlight lang="C">
monitor santuario
{
#define ANDATA 0
#define RITORNO 1
condition oktoenterponte, oktoexitponte ;
int waiting, crossing, medita ;

procedure entry enterponte(ANDATA)
{

if ( crssing(ritorno) > = 0 || crossing(ANDATA) >= maxSantuario || waiting (RITORNO)>0 ) # per evitare deadlock
# deve essere maxSantuario >= maxPonte
waiting (ANDATA)++ ; # crossing(ANDATA) >= maxSantuario
oktoenterponte(ANDATA).wait();
waiting(ANDATA)-- ;
crossing(ANDATA)++ ;
}

procedure entry exitponte(ANDATA) # Entra nel santuario
{
if ( medita == maxSantuario )
oktoexitponte(ANDATA).wait() ;
crossing(ANDATA)--;
medita++ ;
if (waiting(RITORNO) > 0 ) && (crossing(ANDATA)==0)
oktoenterponte(RITORNO).signal();
oktoenterponte(ANDATA).signal();
}

rocedure entry enterponte(RITORNO) # Esci dal santuario
{
if (crossing(ANDATA)>0 || crossing(RTORNO) >= maxPonte)
wiiting(RITORNO)++;
oktoenterponte(RITORNO).wait();
waiting(RITORNO)--;
medita--;
crossing(RITORNO)++;
}

procedure entry exitponte(RITORNO)
{
crossing(RITORNO)--;
if (waiting(RITORNO)>0)
oktoexitponte(RITORNO).signal()
oktoenterponte(ANDATA).signal() ;
}
}

/* Correggetemi se sbaglio.

STARVATION : non l'ho individuata.
Io penso che se al santuario recitassero tutti il rosario e confessassero molti peccati, allora si.
DEADLOCK : se la portata del ponte era piu' grande della portata del santuario si aveva deadlock.
L'ho eliminato mettendo in wait se crossing(ANDATA) >= maxSantuario
*/
save
</syntaxhighlight>

<syntaxhighlight lang="C">
monitor santuario
{
Go = 0; // andare al santuario
Back = 1; // tornare indietro
condition ok[2]; // 2 condizioni
crossing[2] = {0, 0}; // numero di persone sul ponte
visiting = 0; // numero di persone nel santuario
waiting[2] = {0, 0}; // numero di persone in attesa

procedure entry entraponte(dir)
{
/* Mi blocco se:
- il numero di persone sul ponte ha raggiunto il massimo; oppure
- la direzione e' il santuario e il numero di visitatori
(compresi quelli che stanno raggiungendo il santuario) ha raggiunto il massimo; oppure
- qualcuno sta attraversando il ponte in direzione opposta; oppure
- qualcuno sta attendendo di attraversare nel senso opposto */
if (crossing[dir] == MAXPONTE ||
(dir == Go && visiting + crossing[dir] == MAXSANTUARIO) ||
crossing[1 - dir] > 0 ||
waiting[1 - dir] > 0)
{
waiting[dir]++;
ok[dir].wait();
waiting[dir]--;
}
crossing[dir]++;

if (dir == Back)
visiting--;
}

procedure entry esciponte(dir)
{
crossing[dir]--;

if (dir == Go)
visiting++;

// [Case 1] Nessuno sta attraversando il ponte
if (crossing[dir] == 0)
ok[1 - dir].signal();
// [Case 2] Qualcuno sta attraversando il ponte
else
ok[dir].signal();
}
}
</syntaxhighlight>
-TomOgn

<syntaxhighlight lang="C">
monitor santuario{
#define ANDATA 0
#define RITORNO 1

int waiting[2];
int crossing[2];
condition oktoenter[2];
int count; /* persone dentro al santuario */

procedure entry entraponte(int dir){
if (dir == ANDATA){
if (crossing[1-dir] > 0 || crossing[dir] >= MAXPONTE || cout+crossing[dir] >= MAXSANTUARIO){
waiting[dir]++;
oktoenter[dir].wait();
waiting[dir]--;
}
}
else {
if (crossing[1-dir] > 0 || crossing[dir] >= MAXPONTE){
waiting[dir]++;
oktoenter[dir].wait();
waiting[dir]--;
}
}
crossing[dir]++;
if ((crossing[dir]+count < MAXSANTUARIO) && crossing[dir] < MAXPONTE)
oktoenter[dir].signal();
}

procedure entry esciponte(int dir){
crossing[dir]--;
if (dir == ANDATA){
count++;
if (count+crossing[dir] < MAXSANTUARIO) /* voi che siete in attesa andate sul ponte */
oktoenter[dir].signal();
}
else
count--;

if (crossing[dir] == 0)
oktoenter[1-dir].signal();
}
}
</syntaxhighlight>
Gabriele & Giulia (se non va colpa di Gabriele)

<syntaxhighlight lang="C">

monitor santuario{
int CurrentDir /* 0 = arriving , 1 = leaving */
int crossing
condition oktoenter
condition oktoleave
//queue enter
//queue ponte
//queue leave
int fidelis /* fedeli nel tempio */

procedure entry entraponte(CrossingDir){
if(CrossingDir != CurrentDir){
if(CrossingDir == 0){
//enter.enqueue()
oktoenter.wait()
//enter.dequeue()
}
if(CrossingDir == 1){
//leave.enqueue()
oktoleave.wait()
//leave.dequeue()
}
}
if(CrossingDir == 0){
if(fidelis == MAXSANTUARIO || crossing == MAXPONTE){
//ponte.enqueue()
oktoenter.wait()
//ponte.dequeue()
}
fidelis++
crossing++
}
if(CrossingDir == 1){
if(crossing == MAXPONTE){
//ponte.enqueue()
oktoleave.wait()
//ponte.dequeue()
}
fidelis--
crossing++
}
}

precedure entry esciponte(CrossingDir){
crossing--
if(crossing == 0){
if(CrossingDir == 0){
if(fidelis < MAXSANTUARIO /*&& !enter.isempty()*/){
oktoenter.signal()
}
else{
CurrentDir = 1 - CurrentDir
oktoleave.signal()
}
}
else{
CurrentDir = 1 - CurrentDir
oktoenter.signal()
}
}

}

santuario{
crossing = 0
CurrentDir = 0
fidelis = 0
}
}
</syntaxhighlight>
Fede & Mirko

<syntaxhighlight lang="C">

monitor santuario {
condition okpassa; // vai sul ponte secondo metodo FIFO
int turn=2; // turno di attraversamento
int visitatori[2]; // contatori andata ritorno
visitatori[0]=0;
visitatori[1]=0;
int fedeli=0;
int i=0;
Queue q; // coda dei visitatori in attesa

procedure entry entraponte(dir){
/* se il turno è della direzione opposta o
i visitatori in transito sono MAXPONTE o
la coda non è vuota aspetta */
if( (dir==0 && fedeli==MAXSANTUARIO ) || turn==(1-dir) || visitatori[dir]==MAXPONTE || !q.empty()){
q.enqueue(dir); // inserisci in coda
okpassa.wait(); // aspetta
if( q.head()==dir && (visitatori[dir] + i) < (MAXPONTE - 1) ){ // questa condizione
i++;
q.dequeue(); // mi serve per far passare
okpassa.signal(); // MAXPONTE visitatori nella direzione
} // in attesa quando nella direzione opposta
i=0; // i visitatori in transito erano N
}
turn=dir; // setto il turno della direzione
visitatori[dir]++; //incremento visitatori in transito
if(dir==0){fedeli++;}
if(dir==1){fedeli--;}
}

procedure entry esciponte(dir){
visitatore[dir]--; //decremento visitatori in transito
/* se il primo visitatore in attesa va nella stessa direzione
di chi è uscito può entrare sul ponte poichè questo
si verifica solo se il visitatore uscito era il numero N
o il visitatore che esce è l'ultimo fa passare il primo in attesa
che sarà sicuramente della direzione opposta */
primo = (dir == 0 && fedeli < MAXSANTUARIO) && ( q.head()==0 || visitatori[0]==0 ))
secondo = (dir == 1 && (q.head()==0 || visitatori[1]==0 )

if(primo || secondo){
if(visitatore[dir]==0){
turn=2; // ponte vuoto
}
q.dequeue();
okpassa.signal(); // causa il passaggio sul ponte
// del primo visitatore in attesa
// (secondo una politica FIFO)
}

}

</syntaxhighlight>
Alessandro

<syntaxhighlight lang="C">
#define ANDARA 0;
#define RITORNO 1;
monitor santuario{
int cross;
condition oktocross[2];
int fidelis;
entraponte(dir){
if( cross != 0 || (dir == 0 && MAXSANTUARIO == fidelis)){
wait[dir]++;
oktocross[dir].wait();
wait[dir]--;
}
cross++;
if(dir == 0){
fidelis++;
if(cross < MAXPONTE && MAXSANTUARIO > fidelis){
oktocross[dir].signal;
}
}else{
fidelis--;
if(cross < MAXPONTE){
oktocross[dir].signal;
}
}
}
esciponte(dir){
cross--;
if(cross == 0 && MAXSANTUARIO == fidelis){
oktocross[RITORNO].signal();
}else if(cross == 0 && wait[1-dir]){
oktocross[1-dir].signal();
}else if(cross == 0){
oktocross[dir].signal();
}
}
}
</syntaxhighlight>
-Midolo

ProvaTeorica 2012.05.24

2014-06-01T18:04:15Z

Save:

<h1>http://www.cs.unibo.it/~renzo/so/compiti/2012-05-24.tot.pdf</h1>

<syntaxhighlight lang="C">
monitor santuario
{
#define ANDATA 0
#define RITORNO 1
condition oktoenterponte, oktoexitponte ;
int waiting, crossing, medita ;

procedure entry enterponte(ANDATA)
{

if ( crssing(ritorno) > = 0 || crossing(ANDATA) >= maxSantuario || waiting (RITORNO)>0 ) # per evitare deadlock
# deve essere maxSantuario >= maxPonte
waiting (ANDATA)++ ; # crossing(ANDATA) >= maxSantuario
oktoenterponte(ANDATA).wait();
waiting(ANDATA)-- ;
crossing(ANDATA)++ ;
}

procedure entry exitponte(ANDATA) # Entra nel santuario
{
if ( medita == maxSantuario )
oktoexitponte(ANDATA).wait() ;
crossing(ANDATA)--;
medita++ ;
if (waiting(RITORNO) > 0 ) && (crossing(ANDATA)==0)
oktoenterponte(RITORNO).signal();
oktoenterponte(ANDATA).signal();
}

rocedure entry enterponte(RITORNO) # Esci dal santuario
{
if (crossing(ANDATA)>0 || crossing(RTORNO) >= maxPonte)
wiiting(RITORNO)++;
oktoenterponte(RITORNO).wait();
waiting(RITORNO)--;
medita--;
crossing(RITORNO)++;
}

procedure entry exitponte(RITORNO)
{
crossing(RITORNO)--;
if (waiting(RITORNO)>0)
oktoexitponte(RITORNO).signal()
oktoenterponte(ANDATA).signal() ;
}
}

# Correggetemi se sbaglio.

# STARVATION : non l'ho individuata.
Io penso che se al santuario recitassero tutti il rosario e confessassero molti peccati, allora si.
# DEADLOCK : se la portata del ponte era piu' grande della portata del santuario si aveva deadlock.
L'ho eliminato mettendo in wait se crossing(ANDATA) >= maxSantuario

save
</syntaxhighlight>

<syntaxhighlight lang="C">
monitor santuario
{
Go = 0; // andare al santuario
Back = 1; // tornare indietro
condition ok[2]; // 2 condizioni
crossing[2] = {0, 0}; // numero di persone sul ponte
visiting = 0; // numero di persone nel santuario
waiting[2] = {0, 0}; // numero di persone in attesa

procedure entry entraponte(dir)
{
/* Mi blocco se:
- il numero di persone sul ponte ha raggiunto il massimo; oppure
- la direzione e' il santuario e il numero di visitatori
(compresi quelli che stanno raggiungendo il santuario) ha raggiunto il massimo; oppure
- qualcuno sta attraversando il ponte in direzione opposta; oppure
- qualcuno sta attendendo di attraversare nel senso opposto */
if (crossing[dir] == MAXPONTE ||
(dir == Go && visiting + crossing[dir] == MAXSANTUARIO) ||
crossing[1 - dir] > 0 ||
waiting[1 - dir] > 0)
{
waiting[dir]++;
ok[dir].wait();
waiting[dir]--;
}
crossing[dir]++;

if (dir == Back)
visiting--;
}

procedure entry esciponte(dir)
{
crossing[dir]--;

if (dir == Go)
visiting++;

// [Case 1] Nessuno sta attraversando il ponte
if (crossing[dir] == 0)
ok[1 - dir].signal();
// [Case 2] Qualcuno sta attraversando il ponte
else
ok[dir].signal();
}
}
</syntaxhighlight>
-TomOgn

<syntaxhighlight lang="C">
monitor santuario{
#define ANDATA 0
#define RITORNO 1

int waiting[2];
int crossing[2];
condition oktoenter[2];
int count; /* persone dentro al santuario */

procedure entry entraponte(int dir){
if (dir == ANDATA){
if (crossing[1-dir] > 0 || crossing[dir] >= MAXPONTE || cout+crossing[dir] >= MAXSANTUARIO){
waiting[dir]++;
oktoenter[dir].wait();
waiting[dir]--;
}
}
else {
if (crossing[1-dir] > 0 || crossing[dir] >= MAXPONTE){
waiting[dir]++;
oktoenter[dir].wait();
waiting[dir]--;
}
}
crossing[dir]++;
if ((crossing[dir]+count < MAXSANTUARIO) && crossing[dir] < MAXPONTE)
oktoenter[dir].signal();
}

procedure entry esciponte(int dir){
crossing[dir]--;
if (dir == ANDATA){
count++;
if (count+crossing[dir] < MAXSANTUARIO) /* voi che siete in attesa andate sul ponte */
oktoenter[dir].signal();
}
else
count--;

if (crossing[dir] == 0)
oktoenter[1-dir].signal();
}
}
</syntaxhighlight>
Gabriele & Giulia (se non va colpa di Gabriele)

<syntaxhighlight lang="C">

monitor santuario{
int CurrentDir /* 0 = arriving , 1 = leaving */
int crossing
condition oktoenter
condition oktoleave
//queue enter
//queue ponte
//queue leave
int fidelis /* fedeli nel tempio */

procedure entry entraponte(CrossingDir){
if(CrossingDir != CurrentDir){
if(CrossingDir == 0){
//enter.enqueue()
oktoenter.wait()
//enter.dequeue()
}
if(CrossingDir == 1){
//leave.enqueue()
oktoleave.wait()
//leave.dequeue()
}
}
if(CrossingDir == 0){
if(fidelis == MAXSANTUARIO || crossing == MAXPONTE){
//ponte.enqueue()
oktoenter.wait()
//ponte.dequeue()
}
fidelis++
crossing++
}
if(CrossingDir == 1){
if(crossing == MAXPONTE){
//ponte.enqueue()
oktoleave.wait()
//ponte.dequeue()
}
fidelis--
crossing++
}
}

precedure entry esciponte(CrossingDir){
crossing--
if(crossing == 0){
if(CrossingDir == 0){
if(fidelis < MAXSANTUARIO /*&& !enter.isempty()*/){
oktoenter.signal()
}
else{
CurrentDir = 1 - CurrentDir
oktoleave.signal()
}
}
else{
CurrentDir = 1 - CurrentDir
oktoenter.signal()
}
}

}

santuario{
crossing = 0
CurrentDir = 0
fidelis = 0
}
}
</syntaxhighlight>
Fede & Mirko

<syntaxhighlight lang="C">

monitor santuario {
condition okpassa; // vai sul ponte secondo metodo FIFO
int turn=2; // turno di attraversamento
int visitatori[2]; // contatori andata ritorno
visitatori[0]=0;
visitatori[1]=0;
int fedeli=0;
int i=0;
Queue q; // coda dei visitatori in attesa

procedure entry entraponte(dir){
/* se il turno è della direzione opposta o
i visitatori in transito sono MAXPONTE o
la coda non è vuota aspetta */
if( (dir==0 && fedeli==MAXSANTUARIO ) || turn==(1-dir) || visitatori[dir]==MAXPONTE || !q.empty()){
q.enqueue(dir); // inserisci in coda
okpassa.wait(); // aspetta
if( q.head()==dir && (visitatori[dir] + i) < (MAXPONTE - 1) ){ // questa condizione
i++;
q.dequeue(); // mi serve per far passare
okpassa.signal(); // MAXPONTE visitatori nella direzione
} // in attesa quando nella direzione opposta
i=0; // i visitatori in transito erano N
}
turn=dir; // setto il turno della direzione
visitatori[dir]++; //incremento visitatori in transito
if(dir==0){fedeli++;}
if(dir==1){fedeli--;}
}

procedure entry esciponte(dir){
visitatore[dir]--; //decremento visitatori in transito
/* se il primo visitatore in attesa va nella stessa direzione
di chi è uscito può entrare sul ponte poichè questo
si verifica solo se il visitatore uscito era il numero N
o il visitatore che esce è l'ultimo fa passare il primo in attesa
che sarà sicuramente della direzione opposta */
primo = (dir == 0 && fedeli < MAXSANTUARIO) && ( q.head()==0 || visitatori[0]==0 ))
secondo = (dir == 1 && (q.head()==0 || visitatori[1]==0 )

if(primo || secondo){
if(visitatore[dir]==0){
turn=2; // ponte vuoto
}
q.dequeue();
okpassa.signal(); // causa il passaggio sul ponte
// del primo visitatore in attesa
// (secondo una politica FIFO)
}

}

</syntaxhighlight>
Alessandro

<syntaxhighlight lang="C">
#define ANDARA 0;
#define RITORNO 1;
monitor santuario{
int cross;
condition oktocross[2];
int fidelis;
entraponte(dir){
if( cross != 0 || (dir == 0 && MAXSANTUARIO == fidelis)){
wait[dir]++;
oktocross[dir].wait();
wait[dir]--;
}
cross++;
if(dir == 0){
fidelis++;
if(cross < MAXPONTE && MAXSANTUARIO > fidelis){
oktocross[dir].signal;
}
}else{
fidelis--;
if(cross < MAXPONTE){
oktocross[dir].signal;
}
}
}
esciponte(dir){
cross--;
if(cross == 0 && MAXSANTUARIO == fidelis){
oktocross[RITORNO].signal();
}else if(cross == 0 && wait[1-dir]){
oktocross[1-dir].signal();
}else if(cross == 0){
oktocross[dir].signal();
}
}
}
</syntaxhighlight>
-Midolo

ProvaTeorica 2012.05.24

2014-06-01T18:03:09Z

Save:

<h1>http://www.cs.unibo.it/~renzo/so/compiti/2012-05-24.tot.pdf</h1>

<syntaxhighlight lang="C">
monitor santuario
{
#define ANDATA 0
#define RITORNO 1
condition oktoenterponte, oktoexitponte ;
int waiting, crossing, medita ;

procedure entry enterponte(ANDATA)
{

if ( crssing(ritorno) > = 0 || crossing(ANDATA) >= maxSantuario || waiting (RITORNO)>0 ) # per evitare deadlock
# deve essere maxSantuario >= maxPonte
waiting (ANDATA)++ ; # crossing(ANDATA) >= maxSantuario
oktoenterponte(ANDATA).wait();
waiting(ANDATA)-- ;
crossing(ANDATA)++ ;
}

procedure entry exitponte(ANDATA) # Entra nel santuario
{
if ( medita == maxSantuario )
oktoexitponte(ANDATA).wait() ;
crossing(ANDATA)--;
medita++ ;
if (waiting(RITORNO) > 0 ) && (crossing(ANDATA)==0)
oktoenterponte(RITORNO).signal();
oktoenterponte(ANDATA).signal();
}

rocedure entry enterponte(RITORNO) # Esci dal santuario
{
if (crossing(ANDATA)>0 || crossing(RTORNO) >= maxPonte)
wiiting(RITORNO)++;
oktoenterponte(RITORNO).wait();
waiting(RITORNO)--;
medita--;
crossing(RITORNO)++;
}

procedure entry exitponte(RITORNO)
{
crossing(RITORNO)--;
if (waiting(RITORNO)>0)
oktoexitponte(RITORNO).signal()
oktoenterponte(ANDATA).signal() ;
}
}

Correggetemi se sbaglio.

STARVATION : non l'ho individuata.
Io penso che se al santuario recitassero tutti il rosario e confessassero molti peccati, allora si.
DEADLOCK : se la portata del ponte era piu' grande della portata del santuario si aveva deadlock.
L'ho eliminato mettendo in wait se crossing(ANDATA) >= maxSantuario

</syntaxhighlight>
save
<syntaxhighlight lang="C">
monitor santuario
{
Go = 0; // andare al santuario
Back = 1; // tornare indietro
condition ok[2]; // 2 condizioni
crossing[2] = {0, 0}; // numero di persone sul ponte
visiting = 0; // numero di persone nel santuario
waiting[2] = {0, 0}; // numero di persone in attesa

procedure entry entraponte(dir)
{
/* Mi blocco se:
- il numero di persone sul ponte ha raggiunto il massimo; oppure
- la direzione e' il santuario e il numero di visitatori
(compresi quelli che stanno raggiungendo il santuario) ha raggiunto il massimo; oppure
- qualcuno sta attraversando il ponte in direzione opposta; oppure
- qualcuno sta attendendo di attraversare nel senso opposto */
if (crossing[dir] == MAXPONTE ||
(dir == Go && visiting + crossing[dir] == MAXSANTUARIO) ||
crossing[1 - dir] > 0 ||
waiting[1 - dir] > 0)
{
waiting[dir]++;
ok[dir].wait();
waiting[dir]--;
}
crossing[dir]++;

if (dir == Back)
visiting--;
}

procedure entry esciponte(dir)
{
crossing[dir]--;

if (dir == Go)
visiting++;

// [Case 1] Nessuno sta attraversando il ponte
if (crossing[dir] == 0)
ok[1 - dir].signal();
// [Case 2] Qualcuno sta attraversando il ponte
else
ok[dir].signal();
}
}
</syntaxhighlight>
-TomOgn

<syntaxhighlight lang="C">
monitor santuario{
#define ANDATA 0
#define RITORNO 1

int waiting[2];
int crossing[2];
condition oktoenter[2];
int count; /* persone dentro al santuario */

procedure entry entraponte(int dir){
if (dir == ANDATA){
if (crossing[1-dir] > 0 || crossing[dir] >= MAXPONTE || cout+crossing[dir] >= MAXSANTUARIO){
waiting[dir]++;
oktoenter[dir].wait();
waiting[dir]--;
}
}
else {
if (crossing[1-dir] > 0 || crossing[dir] >= MAXPONTE){
waiting[dir]++;
oktoenter[dir].wait();
waiting[dir]--;
}
}
crossing[dir]++;
if ((crossing[dir]+count < MAXSANTUARIO) && crossing[dir] < MAXPONTE)
oktoenter[dir].signal();
}

procedure entry esciponte(int dir){
crossing[dir]--;
if (dir == ANDATA){
count++;
if (count+crossing[dir] < MAXSANTUARIO) /* voi che siete in attesa andate sul ponte */
oktoenter[dir].signal();
}
else
count--;

if (crossing[dir] == 0)
oktoenter[1-dir].signal();
}
}
</syntaxhighlight>
Gabriele & Giulia (se non va colpa di Gabriele)

<syntaxhighlight lang="C">

monitor santuario{
int CurrentDir /* 0 = arriving , 1 = leaving */
int crossing
condition oktoenter
condition oktoleave
//queue enter
//queue ponte
//queue leave
int fidelis /* fedeli nel tempio */

procedure entry entraponte(CrossingDir){
if(CrossingDir != CurrentDir){
if(CrossingDir == 0){
//enter.enqueue()
oktoenter.wait()
//enter.dequeue()
}
if(CrossingDir == 1){
//leave.enqueue()
oktoleave.wait()
//leave.dequeue()
}
}
if(CrossingDir == 0){
if(fidelis == MAXSANTUARIO || crossing == MAXPONTE){
//ponte.enqueue()
oktoenter.wait()
//ponte.dequeue()
}
fidelis++
crossing++
}
if(CrossingDir == 1){
if(crossing == MAXPONTE){
//ponte.enqueue()
oktoleave.wait()
//ponte.dequeue()
}
fidelis--
crossing++
}
}

precedure entry esciponte(CrossingDir){
crossing--
if(crossing == 0){
if(CrossingDir == 0){
if(fidelis < MAXSANTUARIO /*&& !enter.isempty()*/){
oktoenter.signal()
}
else{
CurrentDir = 1 - CurrentDir
oktoleave.signal()
}
}
else{
CurrentDir = 1 - CurrentDir
oktoenter.signal()
}
}

}

santuario{
crossing = 0
CurrentDir = 0
fidelis = 0
}
}
</syntaxhighlight>
Fede & Mirko

<syntaxhighlight lang="C">

monitor santuario {
condition okpassa; // vai sul ponte secondo metodo FIFO
int turn=2; // turno di attraversamento
int visitatori[2]; // contatori andata ritorno
visitatori[0]=0;
visitatori[1]=0;
int fedeli=0;
int i=0;
Queue q; // coda dei visitatori in attesa

procedure entry entraponte(dir){
/* se il turno è della direzione opposta o
i visitatori in transito sono MAXPONTE o
la coda non è vuota aspetta */
if( (dir==0 && fedeli==MAXSANTUARIO ) || turn==(1-dir) || visitatori[dir]==MAXPONTE || !q.empty()){
q.enqueue(dir); // inserisci in coda
okpassa.wait(); // aspetta
if( q.head()==dir && (visitatori[dir] + i) < (MAXPONTE - 1) ){ // questa condizione
i++;
q.dequeue(); // mi serve per far passare
okpassa.signal(); // MAXPONTE visitatori nella direzione
} // in attesa quando nella direzione opposta
i=0; // i visitatori in transito erano N
}
turn=dir; // setto il turno della direzione
visitatori[dir]++; //incremento visitatori in transito
if(dir==0){fedeli++;}
if(dir==1){fedeli--;}
}

procedure entry esciponte(dir){
visitatore[dir]--; //decremento visitatori in transito
/* se il primo visitatore in attesa va nella stessa direzione
di chi è uscito può entrare sul ponte poichè questo
si verifica solo se il visitatore uscito era il numero N
o il visitatore che esce è l'ultimo fa passare il primo in attesa
che sarà sicuramente della direzione opposta */
primo = (dir == 0 && fedeli < MAXSANTUARIO) && ( q.head()==0 || visitatori[0]==0 ))
secondo = (dir == 1 && (q.head()==0 || visitatori[1]==0 )

if(primo || secondo){
if(visitatore[dir]==0){
turn=2; // ponte vuoto
}
q.dequeue();
okpassa.signal(); // causa il passaggio sul ponte
// del primo visitatore in attesa
// (secondo una politica FIFO)
}

}

</syntaxhighlight>
Alessandro

<syntaxhighlight lang="C">
#define ANDARA 0;
#define RITORNO 1;
monitor santuario{
int cross;
condition oktocross[2];
int fidelis;
entraponte(dir){
if( cross != 0 || (dir == 0 && MAXSANTUARIO == fidelis)){
wait[dir]++;
oktocross[dir].wait();
wait[dir]--;
}
cross++;
if(dir == 0){
fidelis++;
if(cross < MAXPONTE && MAXSANTUARIO > fidelis){
oktocross[dir].signal;
}
}else{
fidelis--;
if(cross < MAXPONTE){
oktocross[dir].signal;
}
}
}
esciponte(dir){
cross--;
if(cross == 0 && MAXSANTUARIO == fidelis){
oktocross[RITORNO].signal();
}else if(cross == 0 && wait[1-dir]){
oktocross[1-dir].signal();
}else if(cross == 0){
oktocross[dir].signal();
}
}
}
</syntaxhighlight>
-Midolo

ProvaTeorica 2012.05.24

2014-06-01T18:02:41Z

Save:

<h1>http://www.cs.unibo.it/~renzo/so/compiti/2012-05-24.tot.pdf</h1>

<syntaxhighlight lang="C">
monitor santuario
{
#define ANDATA 0
#define RITORNO 1
condition oktoenterponte, oktoexitponte ;
int waiting, crossing, medita ;

procedure entry enterponte(ANDATA)
{

if ( crssing(ritorno) > = 0 || crossing(ANDATA) >= maxSantuario || waiting (RITORNO)>0 ) # per evitare deadlock
# deve essere maxSantuario >= maxPonte
waiting (ANDATA)++ ; # crossing(ANDATA) >= maxSantuario
oktoenterponte(ANDATA).wait();
waiting(ANDATA)-- ;
crossing(ANDATA)++ ;
}

procedure entry exitponte(ANDATA) # Entra nel santuario
{
if ( medita == maxSantuario )
oktoexitponte(ANDATA).wait() ;
crossing(ANDATA)--;
medita++ ;
if (waiting(RITORNO) > 0 ) && (crossing(ANDATA)==0)
oktoenterponte(RITORNO).signal();
oktoenterponte(ANDATA).signal();
}

rocedure entry enterponte(RITORNO) # Esci dal santuario
{
if (crossing(ANDATA)>0 || crossing(RTORNO) >= maxPonte)
wiiting(RITORNO)++;
oktoenterponte(RITORNO).wait();
waiting(RITORNO)--;
medita--;
crossing(RITORNO)++;
}

procedure entry exitponte(RITORNO)
{
crossing(RITORNO)--;
if (waiting(RITORNO)>0)
oktoexitponte(RITORNO).signal()
oktoenterponte(ANDATA).signal() ;
}
}

Correggetemi se sbaglio.

STARVATION : non l'ho individuata.
Io penso che se al santuario recitassero tutti il rosario e confessassero molti peccati, allora si.
DEADLOCK : se la portata del ponte era piu' grande della portata del santuario si aveva deadlock.
L'ho eliminato mettendo in wait se crossing(ANDATA) >= maxSantuario

save
</syntaxhighlight>

<syntaxhighlight lang="C">
monitor santuario
{
Go = 0; // andare al santuario
Back = 1; // tornare indietro
condition ok[2]; // 2 condizioni
crossing[2] = {0, 0}; // numero di persone sul ponte
visiting = 0; // numero di persone nel santuario
waiting[2] = {0, 0}; // numero di persone in attesa

procedure entry entraponte(dir)
{
/* Mi blocco se:
- il numero di persone sul ponte ha raggiunto il massimo; oppure
- la direzione e' il santuario e il numero di visitatori
(compresi quelli che stanno raggiungendo il santuario) ha raggiunto il massimo; oppure
- qualcuno sta attraversando il ponte in direzione opposta; oppure
- qualcuno sta attendendo di attraversare nel senso opposto */
if (crossing[dir] == MAXPONTE ||
(dir == Go && visiting + crossing[dir] == MAXSANTUARIO) ||
crossing[1 - dir] > 0 ||
waiting[1 - dir] > 0)
{
waiting[dir]++;
ok[dir].wait();
waiting[dir]--;
}
crossing[dir]++;

if (dir == Back)
visiting--;
}

procedure entry esciponte(dir)
{
crossing[dir]--;

if (dir == Go)
visiting++;

// [Case 1] Nessuno sta attraversando il ponte
if (crossing[dir] == 0)
ok[1 - dir].signal();
// [Case 2] Qualcuno sta attraversando il ponte
else
ok[dir].signal();
}
}
</syntaxhighlight>
-TomOgn

<syntaxhighlight lang="C">
monitor santuario{
#define ANDATA 0
#define RITORNO 1

int waiting[2];
int crossing[2];
condition oktoenter[2];
int count; /* persone dentro al santuario */

procedure entry entraponte(int dir){
if (dir == ANDATA){
if (crossing[1-dir] > 0 || crossing[dir] >= MAXPONTE || cout+crossing[dir] >= MAXSANTUARIO){
waiting[dir]++;
oktoenter[dir].wait();
waiting[dir]--;
}
}
else {
if (crossing[1-dir] > 0 || crossing[dir] >= MAXPONTE){
waiting[dir]++;
oktoenter[dir].wait();
waiting[dir]--;
}
}
crossing[dir]++;
if ((crossing[dir]+count < MAXSANTUARIO) && crossing[dir] < MAXPONTE)
oktoenter[dir].signal();
}

procedure entry esciponte(int dir){
crossing[dir]--;
if (dir == ANDATA){
count++;
if (count+crossing[dir] < MAXSANTUARIO) /* voi che siete in attesa andate sul ponte */
oktoenter[dir].signal();
}
else
count--;

if (crossing[dir] == 0)
oktoenter[1-dir].signal();
}
}
</syntaxhighlight>
Gabriele & Giulia (se non va colpa di Gabriele)

<syntaxhighlight lang="C">

monitor santuario{
int CurrentDir /* 0 = arriving , 1 = leaving */
int crossing
condition oktoenter
condition oktoleave
//queue enter
//queue ponte
//queue leave
int fidelis /* fedeli nel tempio */

procedure entry entraponte(CrossingDir){
if(CrossingDir != CurrentDir){
if(CrossingDir == 0){
//enter.enqueue()
oktoenter.wait()
//enter.dequeue()
}
if(CrossingDir == 1){
//leave.enqueue()
oktoleave.wait()
//leave.dequeue()
}
}
if(CrossingDir == 0){
if(fidelis == MAXSANTUARIO || crossing == MAXPONTE){
//ponte.enqueue()
oktoenter.wait()
//ponte.dequeue()
}
fidelis++
crossing++
}
if(CrossingDir == 1){
if(crossing == MAXPONTE){
//ponte.enqueue()
oktoleave.wait()
//ponte.dequeue()
}
fidelis--
crossing++
}
}

precedure entry esciponte(CrossingDir){
crossing--
if(crossing == 0){
if(CrossingDir == 0){
if(fidelis < MAXSANTUARIO /*&& !enter.isempty()*/){
oktoenter.signal()
}
else{
CurrentDir = 1 - CurrentDir
oktoleave.signal()
}
}
else{
CurrentDir = 1 - CurrentDir
oktoenter.signal()
}
}

}

santuario{
crossing = 0
CurrentDir = 0
fidelis = 0
}
}
</syntaxhighlight>
Fede & Mirko

<syntaxhighlight lang="C">

monitor santuario {
condition okpassa; // vai sul ponte secondo metodo FIFO
int turn=2; // turno di attraversamento
int visitatori[2]; // contatori andata ritorno
visitatori[0]=0;
visitatori[1]=0;
int fedeli=0;
int i=0;
Queue q; // coda dei visitatori in attesa

procedure entry entraponte(dir){
/* se il turno è della direzione opposta o
i visitatori in transito sono MAXPONTE o
la coda non è vuota aspetta */
if( (dir==0 && fedeli==MAXSANTUARIO ) || turn==(1-dir) || visitatori[dir]==MAXPONTE || !q.empty()){
q.enqueue(dir); // inserisci in coda
okpassa.wait(); // aspetta
if( q.head()==dir && (visitatori[dir] + i) < (MAXPONTE - 1) ){ // questa condizione
i++;
q.dequeue(); // mi serve per far passare
okpassa.signal(); // MAXPONTE visitatori nella direzione
} // in attesa quando nella direzione opposta
i=0; // i visitatori in transito erano N
}
turn=dir; // setto il turno della direzione
visitatori[dir]++; //incremento visitatori in transito
if(dir==0){fedeli++;}
if(dir==1){fedeli--;}
}

procedure entry esciponte(dir){
visitatore[dir]--; //decremento visitatori in transito
/* se il primo visitatore in attesa va nella stessa direzione
di chi è uscito può entrare sul ponte poichè questo
si verifica solo se il visitatore uscito era il numero N
o il visitatore che esce è l'ultimo fa passare il primo in attesa
che sarà sicuramente della direzione opposta */
primo = (dir == 0 && fedeli < MAXSANTUARIO) && ( q.head()==0 || visitatori[0]==0 ))
secondo = (dir == 1 && (q.head()==0 || visitatori[1]==0 )

if(primo || secondo){
if(visitatore[dir]==0){
turn=2; // ponte vuoto
}
q.dequeue();
okpassa.signal(); // causa il passaggio sul ponte
// del primo visitatore in attesa
// (secondo una politica FIFO)
}

}

</syntaxhighlight>
Alessandro

<syntaxhighlight lang="C">
#define ANDARA 0;
#define RITORNO 1;
monitor santuario{
int cross;
condition oktocross[2];
int fidelis;
entraponte(dir){
if( cross != 0 || (dir == 0 && MAXSANTUARIO == fidelis)){
wait[dir]++;
oktocross[dir].wait();
wait[dir]--;
}
cross++;
if(dir == 0){
fidelis++;
if(cross < MAXPONTE && MAXSANTUARIO > fidelis){
oktocross[dir].signal;
}
}else{
fidelis--;
if(cross < MAXPONTE){
oktocross[dir].signal;
}
}
}
esciponte(dir){
cross--;
if(cross == 0 && MAXSANTUARIO == fidelis){
oktocross[RITORNO].signal();
}else if(cross == 0 && wait[1-dir]){
oktocross[1-dir].signal();
}else if(cross == 0){
oktocross[dir].signal();
}
}
}
</syntaxhighlight>
-Midolo

ProvaTeorica 2012.05.24

2014-06-01T18:01:39Z

Save:

<h1>http://www.cs.unibo.it/~renzo/so/compiti/2012-05-24.tot.pdf</h1>

<syntaxhighlight lang="C">
monitor santuario
{
#define ANDATA 0
#define RITORNO 1
condition oktoenterponte, oktoexitponte ;
int waiting, crossing, medita ;

procedure entry enterponte(ANDATA)
{

if ( crssing(ritorno) > = 0 || crossing(ANDATA) >= maxSantuario || waiting (RITORNO)>0 ) # per evitare deadlock
# deve essere maxSantuario >= maxPonte
waiting (ANDATA)++ ; # crossing(ANDATA) >= maxSantuario
oktoenterponte(ANDATA).wait();
waiting(ANDATA)-- ;
crossing(ANDATA)++ ;
}

procedure entry exitponte(ANDATA) # Entra nel santuario
{
if ( medita == maxSantuario )
oktoexitponte(ANDATA).wait() ;
crossing(ANDATA)--;
medita++ ;
if (waiting(RITORNO) > 0 ) && (crossing(ANDATA)==0)
oktoenterponte(RITORNO).signal();
oktoenterponte(ANDATA).signal();
}

rocedure entry enterponte(RITORNO) # Esci dal santuario
{
if (crossing(ANDATA)>0 || crossing(RTORNO) >= maxPonte)
wiiting(RITORNO)++;
oktoenterponte(RITORNO).wait();
waiting(RITORNO)--;
medita--;
crossing(RITORNO)++;
}

procedure entry exitponte(RITORNO)
{
crossing(RITORNO)--;
if (waiting(RITORNO)>0)
oktoexitponte(RITORNO).signal()
oktoenterponte(ANDATA).signal() ;
}
}

Correggetemi se sbaglio.

STARVATION : non l'ho individuata.
Io penso che se al santuario recitassero tutti il rosario e confessassero molti peccati, allora si.
DEADLOCK : se la portata del ponte era piu' grande della portata del santuario si aveva deadlock.
L'ho eliminato mettendo in wait se crossing(ANDATA) >= maxSantuario

save
</syntaxhighlight>
<syntaxhighlight lang="C">
monitor santuario
{
Go = 0; // andare al santuario
Back = 1; // tornare indietro
condition ok[2]; // 2 condizioni
crossing[2] = {0, 0}; // numero di persone sul ponte
visiting = 0; // numero di persone nel santuario
waiting[2] = {0, 0}; // numero di persone in attesa

procedure entry entraponte(dir)
{
/* Mi blocco se:
- il numero di persone sul ponte ha raggiunto il massimo; oppure
- la direzione e' il santuario e il numero di visitatori
(compresi quelli che stanno raggiungendo il santuario) ha raggiunto il massimo; oppure
- qualcuno sta attraversando il ponte in direzione opposta; oppure
- qualcuno sta attendendo di attraversare nel senso opposto */
if (crossing[dir] == MAXPONTE ||
(dir == Go && visiting + crossing[dir] == MAXSANTUARIO) ||
crossing[1 - dir] > 0 ||
waiting[1 - dir] > 0)
{
waiting[dir]++;
ok[dir].wait();
waiting[dir]--;
}
crossing[dir]++;

if (dir == Back)
visiting--;
}

procedure entry esciponte(dir)
{
crossing[dir]--;

if (dir == Go)
visiting++;

// [Case 1] Nessuno sta attraversando il ponte
if (crossing[dir] == 0)
ok[1 - dir].signal();
// [Case 2] Qualcuno sta attraversando il ponte
else
ok[dir].signal();
}
}
</syntaxhighlight>
-TomOgn

<syntaxhighlight lang="C">
monitor santuario{
#define ANDATA 0
#define RITORNO 1

int waiting[2];
int crossing[2];
condition oktoenter[2];
int count; /* persone dentro al santuario */

procedure entry entraponte(int dir){
if (dir == ANDATA){
if (crossing[1-dir] > 0 || crossing[dir] >= MAXPONTE || cout+crossing[dir] >= MAXSANTUARIO){
waiting[dir]++;
oktoenter[dir].wait();
waiting[dir]--;
}
}
else {
if (crossing[1-dir] > 0 || crossing[dir] >= MAXPONTE){
waiting[dir]++;
oktoenter[dir].wait();
waiting[dir]--;
}
}
crossing[dir]++;
if ((crossing[dir]+count < MAXSANTUARIO) && crossing[dir] < MAXPONTE)
oktoenter[dir].signal();
}

procedure entry esciponte(int dir){
crossing[dir]--;
if (dir == ANDATA){
count++;
if (count+crossing[dir] < MAXSANTUARIO) /* voi che siete in attesa andate sul ponte */
oktoenter[dir].signal();
}
else
count--;

if (crossing[dir] == 0)
oktoenter[1-dir].signal();
}
}
</syntaxhighlight>
Gabriele & Giulia (se non va colpa di Gabriele)

<syntaxhighlight lang="C">

monitor santuario{
int CurrentDir /* 0 = arriving , 1 = leaving */
int crossing
condition oktoenter
condition oktoleave
//queue enter
//queue ponte
//queue leave
int fidelis /* fedeli nel tempio */

procedure entry entraponte(CrossingDir){
if(CrossingDir != CurrentDir){
if(CrossingDir == 0){
//enter.enqueue()
oktoenter.wait()
//enter.dequeue()
}
if(CrossingDir == 1){
//leave.enqueue()
oktoleave.wait()
//leave.dequeue()
}
}
if(CrossingDir == 0){
if(fidelis == MAXSANTUARIO || crossing == MAXPONTE){
//ponte.enqueue()
oktoenter.wait()
//ponte.dequeue()
}
fidelis++
crossing++
}
if(CrossingDir == 1){
if(crossing == MAXPONTE){
//ponte.enqueue()
oktoleave.wait()
//ponte.dequeue()
}
fidelis--
crossing++
}
}

precedure entry esciponte(CrossingDir){
crossing--
if(crossing == 0){
if(CrossingDir == 0){
if(fidelis < MAXSANTUARIO /*&& !enter.isempty()*/){
oktoenter.signal()
}
else{
CurrentDir = 1 - CurrentDir
oktoleave.signal()
}
}
else{
CurrentDir = 1 - CurrentDir
oktoenter.signal()
}
}

}

santuario{
crossing = 0
CurrentDir = 0
fidelis = 0
}
}
</syntaxhighlight>
Fede & Mirko

<syntaxhighlight lang="C">

monitor santuario {
condition okpassa; // vai sul ponte secondo metodo FIFO
int turn=2; // turno di attraversamento
int visitatori[2]; // contatori andata ritorno
visitatori[0]=0;
visitatori[1]=0;
int fedeli=0;
int i=0;
Queue q; // coda dei visitatori in attesa

procedure entry entraponte(dir){
/* se il turno è della direzione opposta o
i visitatori in transito sono MAXPONTE o
la coda non è vuota aspetta */
if( (dir==0 && fedeli==MAXSANTUARIO ) || turn==(1-dir) || visitatori[dir]==MAXPONTE || !q.empty()){
q.enqueue(dir); // inserisci in coda
okpassa.wait(); // aspetta
if( q.head()==dir && (visitatori[dir] + i) < (MAXPONTE - 1) ){ // questa condizione
i++;
q.dequeue(); // mi serve per far passare
okpassa.signal(); // MAXPONTE visitatori nella direzione
} // in attesa quando nella direzione opposta
i=0; // i visitatori in transito erano N
}
turn=dir; // setto il turno della direzione
visitatori[dir]++; //incremento visitatori in transito
if(dir==0){fedeli++;}
if(dir==1){fedeli--;}
}

procedure entry esciponte(dir){
visitatore[dir]--; //decremento visitatori in transito
/* se il primo visitatore in attesa va nella stessa direzione
di chi è uscito può entrare sul ponte poichè questo
si verifica solo se il visitatore uscito era il numero N
o il visitatore che esce è l'ultimo fa passare il primo in attesa
che sarà sicuramente della direzione opposta */
primo = (dir == 0 && fedeli < MAXSANTUARIO) && ( q.head()==0 || visitatori[0]==0 ))
secondo = (dir == 1 && (q.head()==0 || visitatori[1]==0 )

if(primo || secondo){
if(visitatore[dir]==0){
turn=2; // ponte vuoto
}
q.dequeue();
okpassa.signal(); // causa il passaggio sul ponte
// del primo visitatore in attesa
// (secondo una politica FIFO)
}

}

</syntaxhighlight>
Alessandro

<syntaxhighlight lang="C">
#define ANDARA 0;
#define RITORNO 1;
monitor santuario{
int cross;
condition oktocross[2];
int fidelis;
entraponte(dir){
if( cross != 0 || (dir == 0 && MAXSANTUARIO == fidelis)){
wait[dir]++;
oktocross[dir].wait();
wait[dir]--;
}
cross++;
if(dir == 0){
fidelis++;
if(cross < MAXPONTE && MAXSANTUARIO > fidelis){
oktocross[dir].signal;
}
}else{
fidelis--;
if(cross < MAXPONTE){
oktocross[dir].signal;
}
}
}
esciponte(dir){
cross--;
if(cross == 0 && MAXSANTUARIO == fidelis){
oktocross[RITORNO].signal();
}else if(cross == 0 && wait[1-dir]){
oktocross[1-dir].signal();
}else if(cross == 0){
oktocross[dir].signal();
}
}
}
</syntaxhighlight>
-Midolo

ProvaTeorica 2012.05.24

2014-06-01T18:00:03Z

Save:

<h1>http://www.cs.unibo.it/~renzo/so/compiti/2012-05-24.tot.pdf</h1>

<syntaxhighlight lang="C">
monitor santuario
{
#define ANDATA 0
#define RITORNO 1
condition oktoenterponte, oktoexitponte ;
int waiting, crossing, medita ;

procedure entry enterponte(ANDATA)
{

if ( crssing(ritorno) > = 0 || crossing(ANDATA) >= maxSantuario || waiting (RITORNO)>0 ) # per evitare deadlock
# maxSantuario >= maxPonte
waiting (ANDATA)++ ; # crossing(ANDATA) >= maxSantuario
oktoenterponte(ANDATA).wait();
waiting(ANDATA)-- ;
crossing(ANDATA)++ ;
}

procedure entry exitponte(ANDATA) # Entra nel santuario
{
if ( medita == maxSantuario )
oktoexitponte(ANDATA).wait() ;
crossing(ANDATA)--;
medita++ ;
if (waiting(RITORNO) > 0 ) && (crossing(ANDATA)==0)
oktoenterponte(RITORNO).signal();
oktoenterponte(ANDATA).signal();
}

rocedure entry enterponte(RITORNO) # Esci dal santuario
{
if (crossing(ANDATA)>0 || crossing(RTORNO) >= maxPonte)
wiiting(RITORNO)++;
oktoenterponte(RITORNO).wait();
waiting(RITORNO)--;
medita--;
crossing(RITORNO)++;
}

procedure entry exitponte(RITORNO)
{
crossing(RITORNO)--;
if (waiting(RITORNO)>0)
oktoexitponte(RITORNO).signal()
oktoenterponte(ANDATA).signal() ;
}
}

Correggetemi se sbaglio.

STARVATION : non l'ho individuata.
Io penso che se al santuario recitassero tutti il rosario e confessassero molti peccati, allora si.
DEADLOCK : se la portata del ponte era piu' grande della portata del santuario si aveva deadlock.
L'ho eliminato mettendo in wait se crossing(ANDATA) >= maxSantuario

save
</syntaxhighlight>
<syntaxhighlight lang="C">
monitor santuario
{
Go = 0; // andare al santuario
Back = 1; // tornare indietro
condition ok[2]; // 2 condizioni
crossing[2] = {0, 0}; // numero di persone sul ponte
visiting = 0; // numero di persone nel santuario
waiting[2] = {0, 0}; // numero di persone in attesa

procedure entry entraponte(dir)
{
/* Mi blocco se:
- il numero di persone sul ponte ha raggiunto il massimo; oppure
- la direzione e' il santuario e il numero di visitatori
(compresi quelli che stanno raggiungendo il santuario) ha raggiunto il massimo; oppure
- qualcuno sta attraversando il ponte in direzione opposta; oppure
- qualcuno sta attendendo di attraversare nel senso opposto */
if (crossing[dir] == MAXPONTE ||
(dir == Go && visiting + crossing[dir] == MAXSANTUARIO) ||
crossing[1 - dir] > 0 ||
waiting[1 - dir] > 0)
{
waiting[dir]++;
ok[dir].wait();
waiting[dir]--;
}
crossing[dir]++;

if (dir == Back)
visiting--;
}

procedure entry esciponte(dir)
{
crossing[dir]--;

if (dir == Go)
visiting++;

// [Case 1] Nessuno sta attraversando il ponte
if (crossing[dir] == 0)
ok[1 - dir].signal();
// [Case 2] Qualcuno sta attraversando il ponte
else
ok[dir].signal();
}
}
</syntaxhighlight>
-TomOgn

<syntaxhighlight lang="C">
monitor santuario{
#define ANDATA 0
#define RITORNO 1

int waiting[2];
int crossing[2];
condition oktoenter[2];
int count; /* persone dentro al santuario */

procedure entry entraponte(int dir){
if (dir == ANDATA){
if (crossing[1-dir] > 0 || crossing[dir] >= MAXPONTE || cout+crossing[dir] >= MAXSANTUARIO){
waiting[dir]++;
oktoenter[dir].wait();
waiting[dir]--;
}
}
else {
if (crossing[1-dir] > 0 || crossing[dir] >= MAXPONTE){
waiting[dir]++;
oktoenter[dir].wait();
waiting[dir]--;
}
}
crossing[dir]++;
if ((crossing[dir]+count < MAXSANTUARIO) && crossing[dir] < MAXPONTE)
oktoenter[dir].signal();
}

procedure entry esciponte(int dir){
crossing[dir]--;
if (dir == ANDATA){
count++;
if (count+crossing[dir] < MAXSANTUARIO) /* voi che siete in attesa andate sul ponte */
oktoenter[dir].signal();
}
else
count--;

if (crossing[dir] == 0)
oktoenter[1-dir].signal();
}
}
</syntaxhighlight>
Gabriele & Giulia (se non va colpa di Gabriele)

<syntaxhighlight lang="C">

monitor santuario{
int CurrentDir /* 0 = arriving , 1 = leaving */
int crossing
condition oktoenter
condition oktoleave
//queue enter
//queue ponte
//queue leave
int fidelis /* fedeli nel tempio */

procedure entry entraponte(CrossingDir){
if(CrossingDir != CurrentDir){
if(CrossingDir == 0){
//enter.enqueue()
oktoenter.wait()
//enter.dequeue()
}
if(CrossingDir == 1){
//leave.enqueue()
oktoleave.wait()
//leave.dequeue()
}
}
if(CrossingDir == 0){
if(fidelis == MAXSANTUARIO || crossing == MAXPONTE){
//ponte.enqueue()
oktoenter.wait()
//ponte.dequeue()
}
fidelis++
crossing++
}
if(CrossingDir == 1){
if(crossing == MAXPONTE){
//ponte.enqueue()
oktoleave.wait()
//ponte.dequeue()
}
fidelis--
crossing++
}
}

precedure entry esciponte(CrossingDir){
crossing--
if(crossing == 0){
if(CrossingDir == 0){
if(fidelis < MAXSANTUARIO /*&& !enter.isempty()*/){
oktoenter.signal()
}
else{
CurrentDir = 1 - CurrentDir
oktoleave.signal()
}
}
else{
CurrentDir = 1 - CurrentDir
oktoenter.signal()
}
}

}

santuario{
crossing = 0
CurrentDir = 0
fidelis = 0
}
}
</syntaxhighlight>
Fede & Mirko

<syntaxhighlight lang="C">

monitor santuario {
condition okpassa; // vai sul ponte secondo metodo FIFO
int turn=2; // turno di attraversamento
int visitatori[2]; // contatori andata ritorno
visitatori[0]=0;
visitatori[1]=0;
int fedeli=0;
int i=0;
Queue q; // coda dei visitatori in attesa

procedure entry entraponte(dir){
/* se il turno è della direzione opposta o
i visitatori in transito sono MAXPONTE o
la coda non è vuota aspetta */
if( (dir==0 && fedeli==MAXSANTUARIO ) || turn==(1-dir) || visitatori[dir]==MAXPONTE || !q.empty()){
q.enqueue(dir); // inserisci in coda
okpassa.wait(); // aspetta
if( q.head()==dir && (visitatori[dir] + i) < (MAXPONTE - 1) ){ // questa condizione
i++;
q.dequeue(); // mi serve per far passare
okpassa.signal(); // MAXPONTE visitatori nella direzione
} // in attesa quando nella direzione opposta
i=0; // i visitatori in transito erano N
}
turn=dir; // setto il turno della direzione
visitatori[dir]++; //incremento visitatori in transito
if(dir==0){fedeli++;}
if(dir==1){fedeli--;}
}

procedure entry esciponte(dir){
visitatore[dir]--; //decremento visitatori in transito
/* se il primo visitatore in attesa va nella stessa direzione
di chi è uscito può entrare sul ponte poichè questo
si verifica solo se il visitatore uscito era il numero N
o il visitatore che esce è l'ultimo fa passare il primo in attesa
che sarà sicuramente della direzione opposta */
primo = (dir == 0 && fedeli < MAXSANTUARIO) && ( q.head()==0 || visitatori[0]==0 ))
secondo = (dir == 1 && (q.head()==0 || visitatori[1]==0 )

if(primo || secondo){
if(visitatore[dir]==0){
turn=2; // ponte vuoto
}
q.dequeue();
okpassa.signal(); // causa il passaggio sul ponte
// del primo visitatore in attesa
// (secondo una politica FIFO)
}

}

</syntaxhighlight>
Alessandro

<syntaxhighlight lang="C">
#define ANDARA 0;
#define RITORNO 1;
monitor santuario{
int cross;
condition oktocross[2];
int fidelis;
entraponte(dir){
if( cross != 0 || (dir == 0 && MAXSANTUARIO == fidelis)){
wait[dir]++;
oktocross[dir].wait();
wait[dir]--;
}
cross++;
if(dir == 0){
fidelis++;
if(cross < MAXPONTE && MAXSANTUARIO > fidelis){
oktocross[dir].signal;
}
}else{
fidelis--;
if(cross < MAXPONTE){
oktocross[dir].signal;
}
}
}
esciponte(dir){
cross--;
if(cross == 0 && MAXSANTUARIO == fidelis){
oktocross[RITORNO].signal();
}else if(cross == 0 && wait[1-dir]){
oktocross[1-dir].signal();
}else if(cross == 0){
oktocross[dir].signal();
}
}
}
</syntaxhighlight>
-Midolo

ProvaTeorica 2014.02.22

2014-05-30T16:29:17Z

Save:

Testo: [http://www.cs.unibo.it/~renzo/so/compiti/2014.02.21.tot.pdf]

Esercizio c.1

<syntaxhighlight lang="C">
monitor bbwl {
condition oktowrite;
condition oktolog;
condition oktoread;
int logging = 0;
queue q;

procedure entry write (eltype elem) {
if (q.length() == MAXELEM || logging)
oktowrite.wait();
q.enqueue (elem);
logging = 1;
oktolog.signal();
}

procedure entry eltype log() {
if (q.length == 0)
oktolog.wait();
eltype tmp = q.top();
logging = 0;
oktoread.signal();
return tmp;
}

procedure entry eltype read() {
if (q.length == 0 || logging)
oktoread.wait();
eltype tmp = q.dequeue();
oktowrite.signal();
return tmp;
}
}

</syntaxhighlight>

Esercizio c.1
questa è la mia interpretazione
<syntaxhighlight lang="C">

condition oktowrite, oktoread, oktolog ;
queue buffer = MAXELEM ;
queue Llogger ;

monitor bbwl
{
procedure entry write (altype elem)
{
if (buffer.length >= MAXELEM)
oktorite.wait() ;
buffer.enqueue(elem);
oktolog.signal () ;
}

procedur entry logger() # logger deve tenere traccia di tutti i pacchetti transitati mettendoli in una sua memoria.
{
if (buffer.length == 0)
oktolog.wait();
Llogger.enqueue(buffer.front()) # restituisci il valore in testa di buffer e inseriscilo in coda a Llogger
ok toread.signal() ;
}

procedure entry read()
{
if (buffer.length == 0)
oktoread.wait();
buffer.dequeue() # restituisci il valore in testa di buffer e rimuovilo.
oktowrite.signal() ;
}
}

save

</syntaxhighlight>

Esercizio c.2

alpha(x,y): <x=4, y=sqrt(x)>

il valore che viene salvato in y è sempre 2, quindi non va bene.

bravo(x,y): <y=sqrt(x), x=4>

xi yi xf yf
0 0 4 0
0 1 4 1
1 0 4 1
1 1 4 1

il valore iniziale di x viene salvato in y, quindi va bene.

charlie(x,y): <y=sqrt(x), x=4*y>

Anche questo va bene, per le stesse ragioni di bravo.

delta(z,t): <z=z xor t, t=z xor t>

zi ti zf tf
0 0 0 0
0 1 1 0
1 0 1 1
1 1 0 1

Il valore iniziale di z viene salvato in t, quindi va bene.

Esercizio g.1

Sia n=3 il numero di pagine mantenute in memoria

a) 123456789123456789...

MIN = MINNUM
11144777
2225588
333669

b) 145231231231231...

MINNUM

111232123
44444444
5555555

MIN
111111111
44222222
5333333

Alessandro

ProvaTeorica 2014.02.22

2014-05-30T16:10:41Z

Save:

Testo: [http://www.cs.unibo.it/~renzo/so/compiti/2014.02.21.tot.pdf]

Esercizio c.1

<syntaxhighlight lang="C">
monitor bbwl {
condition oktowrite;
condition oktolog;
condition oktoread;
int logging = 0;
queue q;

procedure entry write (eltype elem) {
if (q.length() == MAXELEM || logging)
oktowrite.wait();
q.enqueue (elem);
logging = 1;
oktolog.signal();
}

procedure entry eltype log() {
if (q.length == 0)
oktolog.wait();
eltype tmp = q.top();
logging = 0;
oktoread.signal();
return tmp;
}

procedure entry eltype read() {
if (q.length == 0 || logging)
oktoread.wait();
eltype tmp = q.dequeue();
oktowrite.signal();
return tmp;
}
}

</syntaxhighlight>

Esercizio c.1

<syntaxhighlight lang="C">

condition oktowrite, oktoread, oktolog ;
queue buffer = MAXELEM ;
queue Llogger ;

monitor bbwl
{
procedure entry write (altype elem)
{
if (buffer.length >= MAXELEM)
oktorite.wait() ;
buffer.enqueue(elem);
oktolog.signal () ;
}

procedur entry logger() # logger deve tenere traccia di tutti i pacchetti transitati mettendoli in una sua memoria.
{
if (buffer.length == 0)
oktolog.wait();
Llogger.enqueue(buffer.front()) # restituisci il valore in testa di buffer e inseriscilo in coda a Llogger
ok toread.signal() ;
}

procedure entry read()
{
if (buffer.length == 0)
oktoread.wait();
buffer.dequeue() # restituisci il valore in testa di buffer e rimuovilo.
oktowrite.signal() ;
}
}

save

</syntaxhighlight>

Esercizio c.2

alpha(x,y): <x=4, y=sqrt(x)>

il valore che viene salvato in y è sempre 2, quindi non va bene.

bravo(x,y): <y=sqrt(x), x=4>

xi yi xf yf
0 0 4 0
0 1 4 1
1 0 4 1
1 1 4 1

il valore iniziale di x viene salvato in y, quindi va bene.

charlie(x,y): <y=sqrt(x), x=4*y>

Anche questo va bene, per le stesse ragioni di bravo.

delta(z,t): <z=z xor t, t=z xor t>

zi ti zf tf
0 0 0 0
0 1 1 0
1 0 1 1
1 1 0 1

Il valore iniziale di z viene salvato in t, quindi va bene.

Esercizio g.1

Sia n=3 il numero di pagine mantenute in memoria

a) 123456789123456789...

MIN = MINNUM
11144777
2225588
333669

b) 145231231231231...

MINNUM

111232123
44444444
5555555

MIN
111111111
44222222
5333333

Alessandro

ProvaTeorica 2014.02.22

2014-05-30T16:09:49Z

Save:

Testo: [http://www.cs.unibo.it/~renzo/so/compiti/2014.02.21.tot.pdf]

Esercizio c.1

<syntaxhighlight lang="C">
monitor bbwl {
condition oktowrite;
condition oktolog;
condition oktoread;
int logging = 0;
queue q;

procedure entry write (eltype elem) {
if (q.length() == MAXELEM || logging)
oktowrite.wait();
q.enqueue (elem);
logging = 1;
oktolog.signal();
}

procedure entry eltype log() {
if (q.length == 0)
oktolog.wait();
eltype tmp = q.top();
logging = 0;
oktoread.signal();
return tmp;
}

procedure entry eltype read() {
if (q.length == 0 || logging)
oktoread.wait();
eltype tmp = q.dequeue();
oktowrite.signal();
return tmp;
}
}

</syntaxhighlight>

Esercizio c.1

<syntaxhighlight lang="C">

condition oktowrite, oktoread, oktolog ;
queue buffer = MAXELEM ;
queue Llogger ;

monitor bbwl
{
procedure entry write (altype elem)
{
if (buffer.length >= MAXELEM)
oktorite.wait() ;
buffer.enqueue(elem);
oktolog.signal () ;
}

procedur entry logger() # logger deve tenere traccia di tutti i pacchetti transitati mettendoli in una sua memoria.
{
if (buffer.length == 0)
oktolog.wait();
Llogger.enqueue(buffer.front()) # restituisci il valore in testa di buffer e inseriscilo in coda a Llogger
ok toread.signal() ;
}

procedure entry read()
{
if (buffer.length == 0)
oktoread.wait();
buffer.dequeue() # restituisci il valore in testa di buffer e rimuovilo.
oktowrite.signal() ;
}
}

</syntaxhighlight>

Esercizio c.2

alpha(x,y): <x=4, y=sqrt(x)>

il valore che viene salvato in y è sempre 2, quindi non va bene.

bravo(x,y): <y=sqrt(x), x=4>

xi yi xf yf
0 0 4 0
0 1 4 1
1 0 4 1
1 1 4 1

il valore iniziale di x viene salvato in y, quindi va bene.

charlie(x,y): <y=sqrt(x), x=4*y>

Anche questo va bene, per le stesse ragioni di bravo.

delta(z,t): <z=z xor t, t=z xor t>

zi ti zf tf
0 0 0 0
0 1 1 0
1 0 1 1
1 1 0 1

Il valore iniziale di z viene salvato in t, quindi va bene.

Esercizio g.1

Sia n=3 il numero di pagine mantenute in memoria

a) 123456789123456789...

MIN = MINNUM
11144777
2225588
333669

b) 145231231231231...

MINNUM

111232123
44444444
5555555

MIN
111111111
44222222
5333333

Alessandro

User:Save

2014-05-28T17:01:21Z

Save:

== :-D ==

User:Save

2014-05-28T17:01:06Z

Save: Created page with ":-D"

:-D

Prova Teorica 2013.06.21

2014-05-28T16:13:17Z

Save:

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

<h2> Esercizio c.1 </h2>

<syntaxhighlight lang="C">

monitor nvie
{
condition oktoread;
queue buffer[N];

procedure entry put(int n, generic object)
{

if (buffer[n].length < NELEM)
buffer[n].enqueue(object);

oktoread.signal();

}

procedure entry generic get(generic *object)
{

int count=0;

for (int i=0;i<N;i++)
{
if (buffer[i].length>0)
count++;
return None ;
}
for (int j=0;j<N;j++)
{ if (count>=N/2)
(buffer[j].dequeue(*object) ;
oktoread.wait();
}
}
}

Save
</syntaxhighlight>

<h2> Esercizio g.1 </h2>
[[http://so.v2.cs.unibo.it/wiki/images/0/02/G1paginazione.jpg soluzione]]
<h2> Esercizio c.2 </h2>
<syntaxhighlight lang="C">

#Casi possibili delle iterazioni
int val = 0

PQPQQ (((val +1) *2) +1) * 2 * 2 → 12
PQQPQ (( val +1 ) * 2 * 2) +1 * 2 → 12
QQPQP (((val * 2 * 2) + 1 )* 2) + 1 → 3
QPQQP (((val * 2) + 1) * 2 * 2) + 1 → 5
QPQPQ ((((val * 2) + 1) * 2) + 1) * 2 → 6

a) #Quindi i valori possibili sono → (3, 5, 6, 12)
b) #

</syntaxhighlight>
- Midolo e Marangoni

ProvaTeorica 2013.07.19

2014-05-28T15:40:14Z

Save:

Esecizio C1:
scrivere un monitor m vie che gestisca M buffer limitati. Ogni buffer ha l'ampiezza di M ELEM elementi. I produttori chiamano la procedure entry:
put(generic *object)
mentre i consumatori chiamano la procedure entry
generic *get(int n)
I produttori conferiscono un vettore di M element i, uno per ogni buffer al buffer.
Per esempio put( v ), (dove v e' un vettore di M elementi) inserisce ogni elemento del vettore nel buffer corrispondente.
I consumatori ricevono un oggetto dal buffer indicato come parametro oggetti ma attendono sempre che ci sia almeno un elemento in ogni buffer.

Mia Soluzione:
<syntaxhighlight lang="C">
/*AreEmpy: */
/*true quando almeno un buff é vuoto*/
/*false quando tutti hanno almeno un elemento*/
bool areEmpy(*buff){
for(int a = 0; a<M;a++){
if(buff[a].lengh != 0){
return true;
}
}
return false;
}
/*AreFull: */
/*true quando almeno un buff é pieno*/
/*false quando sono tutti non pieni*/
bool areFull(*buff){
for(int a = 0; a<M;a++){
if (buff[a].lengh == MELEM){
return true;
}
}

return false;
}
monitor mvie{
put(generic *object){
if( areFull(buff) )
oktoput.wait();
for(int a = 0; a<M;a++){
buf[a].queue(object[a]);
}
for(int a = 0; a<M;a++){
oktoget[a].signal();//tutti i buffer hanno almeno un elemento quindi manda la signal a tutti i lettori
}
}

generic *get(int i){
if( areEmpty(buff))
oktoget.wait();
buf[i].dequeue();
if(!areFull(buf)) // se cé spazio in tutti i buffer manda la signal per scrivere
oktoput.signal();
}

}
</syntaxhighlight>
- Midolo

Questa è la mia soluzione:

<syntaxhighlight lang="C">

int everything_set(queue[]) /*prende un array di code e ritorna 1 se sono tutte non vuote*/
int not_full(queue[]) /*prende un array di code e ritorna 1 se tutte le code hanno meno di MELEM elementi*/

monitor mvie
{
queue buf[M];
condition oktowrite,oktoread;
procedure entry put(generic *object)
{
if (!not_full(buf))
oktowrite.wait();
for (i=0;i<M;i++)
{
buf[i].enqueue(object[i]);
}
oktoread.signal();
}
procedure entry generic* get (int n)
{
if (!everything_set(buf))
oktoread.wait();
generic g=buf[n].dequeue();
if (not_full(buf)
oktowrite.signal();
}
}

</syntaxhighlight>
-stefano92

Secondo me, bloccare il processo che vuole fare PUT, nel caso in cui esiste un buffer pieno, determina DEADLOCK.

Infatti il testo non lo chiede. Faccio un esempio:

Buffer 1: (empty)

Buffer 2: (full)

Processo 1: GET -> si blocca in quanto il Buffer 1 e' vuoto.

Processo 2: PUT -> si blocca in quanto il Buffer 2 e' pieno.

...etc...

DEADLOCK

Quando aggiungi a tutti e togli a 1 solo, e' plausibile che si formi, prima o poi, la situazione descritta sopra: un buffer pieno e uno vuoto.
Nella mia soluzione quindi non c'e' questo controllo.

<syntaxhighlight lang="C">
monitor mvie
{
condition okP, okG;
queue buf[M];

bool isOneEmpty()
{
for (int i = 0; i < M; i++)
if (buf[i].isEmpty())
return true;

return false;
}

procedure entry put(generic *object)
{
for (int i = 0; i < M; i++)
if (buf[i].length() < MELEM)
buf[i].enqueue(object[i]);

okG.signal();
}

procedure entry generic *get(int n)
{
if (isOneEmpty())
okG.wait();

return buf[n].dequeue();
}
}
</syntaxhighlight>

-TomOgn

uhm...per l'idea di buffer come l'abbiamo sempre visto mi sembra strano che una put su un buffer pieno vada "buttata"...
d'altronde anche quello che dici tu è vero, ponendo attesa in caso di buffer pieno si provoca indubbiamente deadlock XD

----

<syntaxhighlight lang="C">

monitor mvie{
queue buffer[M];
condition oktoput;
condition oktoget;

mvie(){
int i;
for(i=0; i<M; i++)
buffer[i] = new queue(MELEM);
}

put(generic *object){
int i;
boolean b=1;
for(i=0; i<M; i++){
if(!(buffer[i].len < MELEM))
b=0;
}
if(b == 0) /*almeno un elemento non era disponibile*/
oktoput.wait();

for(i=0; i<M; i++)
buffer[i].enqueue(object[i]);
oktoget.signal();
}

generic *get(int n){
int i;
boolean b=1;
for(i=0; i<M; i++){
if(buffer[i].len == 0)
b=0;
}
if(b == 0)
oktoget.wait();

object toread = buffer[n].dequeue;
/* dobbiamo controllare che ci sia almeno un elemento libero per ciascun buffer prima di fare la signal */
b = 1;
for(i=0; i<M; i++){
if(!(buffer[i].len < MELEM))
b=0;
}
if(b)
oktoput.signal();
}
}
</syntaxhighlight>
Gabriele e Giulia
<syntaxhighlight lang="C">

monitor mvie
{
condition oktoread;
queue buffer[M];

bool control1empty()
{
for (int i = 0; i < M; i++)
if (buffer[i].length==0)
return true;

return false;
}

procedure entry put(generic *object)
{
for (int i = 0; i < M; i++)
{
if (buffer[i].length < MELEM)
buffer[i].enqueue(object[i]);

}
oktoread.signal();

}

procedure entry generic *get(int n)
{

if (control1empty()) # se trova un buffer vuoto, wait.
oktoread.wait();

return buffer[n].dequeue(); # consuma l'oggetto n
}
}

Save

</syntaxhighlight>

ProvaTeorica 2013.07.19

2014-05-28T15:38:49Z

Save:

Esecizio C1:
scrivere un monitor m vie che gestisca M buffer limitati. Ogni buffer ha l'ampiezza di M ELEM elementi. I produttori chiamano la procedure entry:
put(generic *object)
mentre i consumatori chiamano la procedure entry
generic *get(int n)
I produttori conferiscono un vettore di M element i, uno per ogni buffer al buffer.
Per esempio put( v ), (dove v e' un vettore di M elementi) inserisce ogni elemento del vettore nel buffer corrispondente.
I consumatori ricevono un oggetto dal buffer indicato come parametro oggetti ma attendono sempre che ci sia almeno un elemento in ogni buffer.

Mia Soluzione:
<syntaxhighlight lang="C">
/*AreEmpy: */
/*true quando almeno un buff é vuoto*/
/*false quando tutti hanno almeno un elemento*/
bool areEmpy(*buff){
for(int a = 0; a<M;a++){
if(buff[a].lengh != 0){
return true;
}
}
return false;
}
/*AreFull: */
/*true quando almeno un buff é pieno*/
/*false quando sono tutti non pieni*/
bool areFull(*buff){
for(int a = 0; a<M;a++){
if (buff[a].lengh == MELEM){
return true;
}
}

return false;
}
monitor mvie{
put(generic *object){
if( areFull(buff) )
oktoput.wait();
for(int a = 0; a<M;a++){
buf[a].queue(object[a]);
}
for(int a = 0; a<M;a++){
oktoget[a].signal();//tutti i buffer hanno almeno un elemento quindi manda la signal a tutti i lettori
}
}

generic *get(int i){
if( areEmpty(buff))
oktoget.wait();
buf[i].dequeue();
if(!areFull(buf)) // se cé spazio in tutti i buffer manda la signal per scrivere
oktoput.signal();
}

}
</syntaxhighlight>
- Midolo

Questa è la mia soluzione:

<syntaxhighlight lang="C">

int everything_set(queue[]) /*prende un array di code e ritorna 1 se sono tutte non vuote*/
int not_full(queue[]) /*prende un array di code e ritorna 1 se tutte le code hanno meno di MELEM elementi*/

monitor mvie
{
queue buf[M];
condition oktowrite,oktoread;
procedure entry put(generic *object)
{
if (!not_full(buf))
oktowrite.wait();
for (i=0;i<M;i++)
{
buf[i].enqueue(object[i]);
}
oktoread.signal();
}
procedure entry generic* get (int n)
{
if (!everything_set(buf))
oktoread.wait();
generic g=buf[n].dequeue();
if (not_full(buf)
oktowrite.signal();
}
}

</syntaxhighlight>
-stefano92

Secondo me, bloccare il processo che vuole fare PUT, nel caso in cui esiste un buffer pieno, determina DEADLOCK.

Infatti il testo non lo chiede. Faccio un esempio:

Buffer 1: (empty)

Buffer 2: (full)

Processo 1: GET -> si blocca in quanto il Buffer 1 e' vuoto.

Processo 2: PUT -> si blocca in quanto il Buffer 2 e' pieno.

...etc...

DEADLOCK

Quando aggiungi a tutti e togli a 1 solo, e' plausibile che si formi, prima o poi, la situazione descritta sopra: un buffer pieno e uno vuoto.
Nella mia soluzione quindi non c'e' questo controllo.

<syntaxhighlight lang="C">
monitor mvie
{
condition okP, okG;
queue buf[M];

bool isOneEmpty()
{
for (int i = 0; i < M; i++)
if (buf[i].isEmpty())
return true;

return false;
}

procedure entry put(generic *object)
{
for (int i = 0; i < M; i++)
if (buf[i].length() < MELEM)
buf[i].enqueue(object[i]);

okG.signal();
}

procedure entry generic *get(int n)
{
if (isOneEmpty())
okG.wait();

return buf[n].dequeue();
}
}
</syntaxhighlight>

-TomOgn

uhm...per l'idea di buffer come l'abbiamo sempre visto mi sembra strano che una put su un buffer pieno vada "buttata"...
d'altronde anche quello che dici tu è vero, ponendo attesa in caso di buffer pieno si provoca indubbiamente deadlock XD

----

<syntaxhighlight lang="C">

monitor mvie{
queue buffer[M];
condition oktoput;
condition oktoget;

mvie(){
int i;
for(i=0; i<M; i++)
buffer[i] = new queue(MELEM);
}

put(generic *object){
int i;
boolean b=1;
for(i=0; i<M; i++){
if(!(buffer[i].len < MELEM))
b=0;
}
if(b == 0) /*almeno un elemento non era disponibile*/
oktoput.wait();

for(i=0; i<M; i++)
buffer[i].enqueue(object[i]);
oktoget.signal();
}

generic *get(int n){
int i;
boolean b=1;
for(i=0; i<M; i++){
if(buffer[i].len == 0)
b=0;
}
if(b == 0)
oktoget.wait();

object toread = buffer[n].dequeue;
/* dobbiamo controllare che ci sia almeno un elemento libero per ciascun buffer prima di fare la signal */
b = 1;
for(i=0; i<M; i++){
if(!(buffer[i].len < MELEM))
b=0;
}
if(b)
oktoput.signal();
}
}
</syntaxhighlight>
Gabriele e Giulia
<syntaxhighlight lang="C">

monitor mvie
{
condition oktowrite, oktoread;
queue buffer[M];

bool control1empty()
{
for (int i = 0; i < M; i++)
if (buffer[i].length==0)
return true;

return false;
}

procedure entry put(generic *object)
{
for (int i = 0; i < M; i++)
{
if (buffer[i].length < MELEM)
buf[i].enqueue(object[i]);

}
oktoread.signal();

}

procedure entry generic *get(int n)
{

if (control1empty()) # se trova un buffer vuoto, wait.
oktoread.wait();

return buffer[n].dequeue(); # consuma l'oggetto n
}
}

Save

</syntaxhighlight>

ProvaTeorica 2012.02.09

2014-05-28T14:53:11Z

Save:

Esercizio 1
<syntaxhighlight lang="C">
/*
Esercizio 1: Il monitor seq da implementare deve fornire due procedure entry:
procedure entry void enter(void);
procedure entry void exit(void);
I processi chiamano i servizi di seq come segue:
….
seq.enter();
// codice controllato da seq
seq.exit();
….
Tutti i processi che ne facciano rischiesta possono entrare nel codice controllato da seq contemporaneamente (questa
NON e' una sezione critica!). Exit deve garantire che i processi escano dal codice controllato tutti insieme. Per
esempio se tre processi a,b e c chiamano seq.enter ogni processo non potra' completare la exit se prima tutti gli altri
due non hanno chiamato la exit. Se nel frattempo altri processi dovessero chiamare la seq.enter occorrera' attendere
anche questi ultimi.
*/

monitor seq
{
int processi=0;
condition oktoexit;

procedure entry enter()
{
processi++
}

procedure entry exit()
{
processi--
oktoexit.signal();
while(processi!=0)
{
oktoexit.wait();
}

}
}
</syntaxhighlight>
-stefano92

<syntaxhighlight lang="C">

monitor seq
{
int processi=0;
condition oktoexit;

procedure entry enter()
{
processi++
}

procedure entry exit()
{

int inattesa=0 ;
processi-- ;

while(processi!=0)
{
inattesa++ ;
oktoexit.wait();
inattesa=0;
}

oktoexit.signal();
}
}

Save

</syntaxhighlight>