Sistemi Operativi - User contributions [en]

20220906c2

2023-05-31T06:00:07Z

LiberaL: /* Correzioni proposte */

In questa pagina sono presenti alcune soluzioni (possibilmente con errore) per l'esercizio C2 dell'esame 2022/09/06.
Il lettore è invitato a immedesimare il professore al momento della correzione durante la lettura delle soluzioni.

== Consegna ==
Usando i semafori implementare un servizio che preveda due funzioni:
void sumstop(int v)
int sumgo(void)
La funzione sumstop deve mettere il processo chiamante in attesa.
La funzione sumgo deve sbloccare tutti i processi messi in attesa con la sumstop e restituire la somma algebrica dei valori passati come parametro alla sumstop dai processi che sono stati sbloccati (zero se la sumgo viene richiamata quando non c'è nessun processo bloccato).
== 1 ==
<pre>
semaphore sem(1);
int sum=0;
queue q;

void sumstop(int v):
if i < 0:
q.enqueue(v)
sem.P()
else
i--

int sumgo(void):
for each elem in q:
int val=q.dequeue()
sum=sum + val
return sum

</pre>
== 2 ==
<pre>
queue values;
semaphore s(0);
int sum=0;

void sumstop(int v):
s.P()
values.enqueue(v)

int sumgo(void):
while !value.isEmpty():
s.V()
mutex.P()
sum=sum+values.dequeue()
mutex.v()
return sum

</pre>
== 3 ==
<pre>
shared int sum=0;
semaphore wait(0);
semaphore mutex(1);

void sumstop(int v):
mutex.P();
sum = sum + v;
mutex.V();
wait.P();

int sumgo(void):
wait.V();
somma = sum;
mutex.P()
sum = 0
mutex.V()
return somma;

</pre>
== 4 ==
<pre>
queue<int> processlist;
semaphore mutex(1);
semaphore s(0);

void sumstop(int v):
mutex.P();
processlist.enqueue(v);
mutex.P(); // V non P
S.P();

int sumgo(void):
int sum = 0;
mutex.P();
while processlist.top() != NULL:
sum += processlist.dequeue();
S.V();
mutex.V()
return sum;

</pre>

== 5 ==
<pre>
int counter = 0;
int sum = 0;
semaphore mutex(1);
semaphore blocked(0);

void sumstop(int v):
mutex.P();
sum+=v;
counter++;
mutex.V();
blocked.P();

int sumgo(void):
mutex.P();
intret = sum;
sum = 0;
for (int i=0; i<counter; i++)
blocked.V()
counter = 0;
mutex.V()
return intret

</pre>

== 6 ==
<pre>
int sum = 0;
mutex = new semaphore(1);
queue q;

void sumstop(int v):
mutex.P();
sum += v;
sintpid = getpid();
suspend(pid);
mutex.V();

int sumgo(void):
mutex.P();
while !q.empty():
resume(q.dequeue())
int value = sum;
sum = 0;
return value;

</pre>
== 7 ==
<pre>
int nP, nV = -1, 0;
int somma = 0
int val[]
semaphore mutex(1);
semaphore s(0);

void sumstop(int v):
mutex.P()
val[nP++].add[v]
s.P()
np--
v[0].delete

int sumgo(void):
mutex.P();
nV++
if nP > 0:
s.V()
for (int i=0; i<nV; i++)
somma += val[i]
nv--
else
mutex.V()
return somma

</pre>
== 8 ==
<pre>
struct blocked {
semaphore sem(0);
int value = 0;
};

semaphore mutex(1);
list<blocked> procs = new list<blocked>();

void sumstop(int v):
mutex.P()
blocked bl = new blocked();
bl.value = v
procs.add(bl)
bl.sem.P()
mutex.V()

int sumgo(void):
mutex.P();
int count = 0;
foreach proc in procs:
count += proc.value
procs.remove(proc)
proc.sem.V()
mutex.V()
return count;

</pre>
== 9 ==
<pre>
semaphore s[] new sem(0)
semaphore s1 new sem(0)
int tot, waiting = 0;

void sumstop(int v):
waiting++
s[waiting - 1].P()
waiting--
tot = tot + v
if waiting == 0:
s1.V()

int sumgo(void):
if waiting = 0:
return 0
for (i = waiting -1; i == 0; i--)
s[i].V()
s1.P() // per aspettare che tutti abbiano fatto la somma
return tot

</pre>

== 10 ==
<pre>
int nw = 0
int currsum = 0
semaphore mutex(1)
semaphore wait2go(0)

void sumstop(int v):
mutex.P()
currsum += v;
nw++;
mutex.V()
wait2go.P()
if --nw > 0:
wait2go.V()
else
mutex.V()

int sumgo(void):
mutex.P();
if nw == 0:
mutex.V()
return 0;
int sum = cursum;
cursum = 0;
wait2go.V();
return sum

</pre>
== 11==
<pre>
semaphore mutex(1);
semaphore semwait(0);
int sum=0;
int wait=0;

void sumstop(int v):
mutex.P()
wait++
sum += v;
mutex.V()
semwait.P()
mutex.P()
wait--;
mutex.V()
if wait > 0:
semwait.V()

int sumgo(void):
if wait == 0:
return 0
semwait.V();
while (wait > 0) {}
int val = sum
mutex.P()
sum = 0;
mutex.V()
return val;

</pre>
== 12 ==
<pre>
semaphore mutex(0)
volatile int counter = 0

void sumstop(int v):
counter = counter + v;
mutex.P()

int sumgo(void):
int val = counter;
while (mutex.value != 0)
mutex.V()
counter = 0;
return counter

</pre>
== 13 ==
<pre>
semaphore mutex(1)
int sum = 0;
queue of semaphore q;

void sumstop(int v):
mutex.P()
sum += v;
s = new semaphore(0);
q.enqueue(s)
mutex.V()
s.P()
free(s)

int sumgo(void):
mutex.P()
int lsum = sum
sum = 0
while (!q.empty()):
semaphore s = q.dequeue()
s.V()
mutex.V()

</pre>
== 14 ==
<pre>
semaphore mutex(1)
int sum = 0;
queue of semaphore q;

void sumstop(int v):
mutex.P()
sum += v;
s = new semaphore(0);
q.enqueue(s)
mutex.V()
s.P()
free(s)
if(q.empty())
mutex.V()
else
semaphore s = q.dequeue()
s.V()

int sumgo(void):
mutex.P()
int lsum = sum
sum = 0
if(q.empty())
mutex.V()
else
semaphore s = q.dequeue()
s.V()

</pre>

== 15 (soluzione proposta su telegram) ==
<syntaxhighlight lang=C>
#include <pthread.h>
#include "semaphore.h"

semaphore s; // semaforo che blocca le somme
semaphore finished; // semaforo che indica che le somme sono state fatte
semaphore critical_section; // sarà utilizzata per decidere chi entra nella critical section

volatile int sumstops = 0;
volatile int result;

void *sumstop(int v) {
semaphore_P(critical_section);
sumstops++;
semaphore_V(critical_section);

semaphore_P(s);
printf("summed %d\n", v);
result += v;
semaphore_V(finished);
}

int sumgo(void) {
semaphore_P(critical_section); // così sumstops è costante all'interno di questa section
result = 0;
for (int i = 0; i < sumstops; i++) {
semaphore_V(s); // permetti alla somma di andare
semaphore_P(finished); // aspetta che la somma sia finita prima di continuare
}
sumstops = 0; // reset number of blocked stops.
semaphore_V(critical_section);
return result;
}

void *run_sumgo(void) {
int res = sumgo();
printf("the result found is %d\n", res);
printf("the result found is %d\n", result);
}

int main() {
srand(time(NULL));
s = semaphore_create(0);
critical_section = semaphore_create(1);
finished = semaphore_create(0);

int n = rand() % 50;
pthread_t sumg, s[n];

for (int i = 0; i < n; i++) {
pthread_create(&s[i], NULL, sumstop, i);
}
pthread_create(&sumg, NULL, run_sumgo, NULL);

for (int i = 0; i < 10; i++) {
pthread_join(s[i], NULL);
}

pthread_join(sumg, NULL);
}

</syntaxhighlight>

== 16 - Soluzione di uno studente ==
<syntaxhighlight>
//Variabili globali
Queue<Semaphore> processSemaphore = new Queue();
Semaphore mutex = new Semaphore(1);
Queue<int> integers = new Queue();

int SumGo() {

int sum = 0;
mutex.P();
while(processSemaphore.isQueueVoid() == false){
Semaphore procSem = processSemaphore.dequeue();
procSem.V();
}
while(integers.isQueueVoid() == false){
sum = sum + integers.dequeue();
}
mutex.V();
return sum;
}

void SumStop(int generatedValue){
Semaphore sem = new Semaphore(0);
mutex.P();
integers.enqueue(generatedValue);
processSemaphore.enqueue(sem);
mutex.V();
sem.P();
free(sem);
}
</syntaxhighlight>

== Correzioni proposte ==

Correzione proposta da [https://t.me/flecarts flecart]
(e poi modificata successivamente da altri studenti ... tra cui: [https://t.me/LLibera LLibera] )

1. la variabile i non è inizializzata, sum e queue non sono protette in critical sections, inoltre la sem.V() non compare mai nel codice della sumgo.

2. la coda value non è in una critical section, può creare errori nell'update di essa, solo sum viene considerata da proteggere, ma devono essere protette entrambe. La enqueue avrebbe senso farla solo prima di bloccarsi nel semaforo, se viene fatta dopo al momento della chiamata di sumgo non ci sono valori all'interno della coda!

3. sumgo libera solamente un singolo sumstop, perché chiama wait.V() una singola volta anche se ci sono più thread in attesa

4. mutex.P() è chiamata due volte in sumstop(), se il secondo fosse mutex.V() credo sia corretto.
//dopo il commento del prof: supponiamo che sia mutex.V() allora nella sumstop dopo S.P dovremmo ancora rilasciare la mutex...
ma rilasciando la mutex non riesco a finire di liberare gli altri processi quindi è meglio pensare meglio il while nella sumstop in modo da fare un passaggio del testimone che sblocchi tutti in cascata.

5. mi sembra corretto (ma l'indentazione è poco sensata).

6. non si possono utilizzare suspend o resume (non si è fatto uso di semafori, e l'implementazione deve essere fatta all'esterno del kernel non all'interno). Oltre a questo pid non è inizializzata e sintpid non è utilizzata. Se anche la suspend fosse una sem.P() e la resume una sem.V() non dovremmo sospendere il processo all'interno della mutua esclusione.

7. nP e nV mi sembrano superflue, in questo caso sicuramente scorrette perché se chiamo m volte sumstop e una volta sumgo, nV è al massimo 1
quindi è impossibile che riesca a contare correttamente tutte le somme.

8. Deadlock perché bl.sem.P() è chiamato prima che ls Critical Section venga rilasciata e sumgo ha bisogno di entrare in una CS.

9. waiting è una variabile globale modificata senza cs, e tot non è inizializzato.

10. simile a 3. wait2go è chiamata una volta quindi può liberare solamente un singolo thread di sumstop.

11. busy waiting in sumgo.

12. counter non è protetto da Critical section

13. se sumgo ritornasse il valore lsum sarebbe tutto apposto.

14. mi sembra corretto, manca solo la return in sumgo

15. mi sembra corretto

Prove scritte 2017

2023-05-29T04:05:20Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [[User:LiberaL|LiberaL]] 14:26, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo ([[User:LiberaL|LiberaL]] 06:04, 29 May 2023 (CEST)) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

myDictionaryQueue of <pid_t, msg_type> db; //nota: salvo qui solo se il messaggio è per me, quindi dest non mi serve

arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;
if( ( <mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;

do {
<dst, mit, msg> = brecv(*); //ricevo
if( dst == getpid() ) { //il messaggio è per me?
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
return msg; //esci dal while
//se devo salvarlo (sender specificato e messaggio per me)
//metto in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<mit, msg>);
}
} while ( true ) //devo uscire solo con il return
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-29T04:04:17Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [[User:LiberaL|LiberaL]] 14:26, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo ([[User:LiberaL|LiberaL]] 06:04, 29 May 2023 (CEST)) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, msg_type> db; //nota: salvo qui solo se il messaggio è per me, quindi dest non mi serve

arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;
if( ( <mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;

do {
<dst, mit, msg> = brecv(*); //ricevo
if( dst == getpid() ) { //il messaggio è per me?
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
return msg; //esci dal while
//se devo salvarlo (sender specificato e messaggio per me)
//metto in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<mit, msg>);
}
} while ( true ) //devo uscire solo con il return
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-29T03:56:55Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [[User:LiberaL|LiberaL]] 14:26, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo ([[User:LiberaL|LiberaL]] 05:56, 29 May 2023 (CEST)) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, msg_type> db; //nota: salvo qui solo se il messaggio è per me, quindi dest non mi serve

arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;
if( ( <mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;

do {
<dst, mit, msg> = brecv(*); //ricevo
if( dst == getpid() ) { //il messaggio è per me?
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
break; //esci dal while
//se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<mit, msg>);
//devo anche continuare a ricevere altri messaggi
}
} while ( true ) //devo uscire solo con il break

return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-29T03:50:59Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [[User:LiberaL|LiberaL]] 14:26, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo ([[User:LiberaL|LiberaL]] 05:50, 29 May 2023 (CEST)) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, msg_type> db; //nota: salvo qui solo se il messaggio è per me, quindi dest non mi serve

arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;
if( ( <mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;

do {
<dst, mit, msg> = brecv(*); //ricevo
if( dst == getpid() ) { //il messaggio è per me?
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
break; //esci dal while
else { //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<mit, msg>);
//devo anche continuare a ricevere altri messaggi
}
}
} while ( true ) //devo uscire solo con il break

return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-29T03:38:02Z

LiberaL: /*continuo a ricevere se ho salvato il messaggio in db*/

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [[User:LiberaL|LiberaL]] 14:26, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo ([[User:LiberaL|LiberaL]] 05:36, 29 May 2023 (CEST)) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, msg_type> db; //nota: salvo qui solo se il messaggio è per me, quindi dest non mi serve

arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;
if( ( <mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;

bool message_for_me, continue_save = false;
do {
<dst, mit, msg> = brecv(*); //ricevo
message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me ) {
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
break; //esci dal while
else { //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<mit, msg>);
continue_save = true; //devo anche continuare a ricevere altri messaggi
}
}
} while ( !message_for_me || continue_save )

return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-29T03:36:50Z

LiberaL: /*continuo a ricevere se ho salvato il messaggio in db*/

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [[User:LiberaL|LiberaL]] 14:26, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo ([[User:LiberaL|LiberaL]] 05:36, 29 May 2023 (CEST)) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, msg_type> db; //nota: salvo qui solo se il messaggio è per me, quindi dest non mi serve

arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;
if( ( <mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;

bool message_for_me, continue = false;
do {
<dst, mit, msg> = brecv(*); //ricevo
message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me ) {
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
break; //esci dal while
else { //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<mit, msg>);
continue = true; //devo anche continuare a ricevere altri messaggi
}
}
} while ( !message_for_me || continue )

return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-27T11:22:08Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [[User:LiberaL|LiberaL]] 14:26, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo ([[User:LiberaL|LiberaL]] 13:11, 27 May 2023 (CEST)) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, msg_type> db; //nota: salvo qui solo se il messaggio è per me, quindi dest non mi serve

arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;
if( ( <mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;

bool message_for_me;
do {
<dst, mit, msg> = brecv(*); //ricevo
message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me ) {
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
break; //esci dal while
else //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<mit, msg>);
}
} while (!message_for_me)

return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-27T11:21:17Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [[User:LiberaL|LiberaL]] 14:26, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo ([[User:LiberaL|LiberaL]] 13:11, 27 May 2023 (CEST)) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, msg_type> db; //nota: salvo qui solo se il messaggio è per me, quindi dest non mi serve
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;
if( ( <mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;

bool message_for_me;
do {
<dst, mit, msg> = brecv(*); //ricevo
message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me ) {
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
break; //esci dal while
else //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-27T11:11:39Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [[User:LiberaL|LiberaL]] 14:26, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo ([[User:LiberaL|LiberaL]] 13:11, 27 May 2023 (CEST)) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, msg_type> db; //nota: salvo qui solo se il messaggio è per me, quindi dest non mi serve
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;

if( ( <mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;
bool message_for_me;
do {
<dst, mit, msg> = brecv(*); //ricevo
message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me ) {
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
break; //esci dal while
else //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-27T11:06:13Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [[User:LiberaL|LiberaL]] 14:26, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo (13:04, 27 May 2023 (CEST)) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, msg_type> db; //nota: salvo qui solo se il messaggio è per me, quindi dest non mi serve
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;

if( ( <mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;
bool message_for_me;
do {
<dst, mit, msg> = brecv(*); //ricevo
message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me ) {
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
break; //esci dal while
else //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-27T11:05:02Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [[User:LiberaL|LiberaL]] 14:26, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo (13:04, 27 May 2023 (CEST)) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, msg_type> db; //nota: salvo qui solo se il messaggio è per me quindi dest non mi serve sarebbe sempre == getpid()
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;

if( ( <mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;
bool message_for_me;
do {
<dst, mit, msg> = brecv(*); //ricevo
message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me ) {
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
break; //esci dal while
else //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-27T11:04:06Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [[User:LiberaL|LiberaL]] 14:26, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo (13:04, 27 May 2023 (CEST)) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, msg_type> db; //nota: salvo qui solo se il messaggio è per me quindi dest non mi serve sarebbe sempre == getpid()
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;

if( ( <mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;
bool message_for_me;
do {
<dst, mit, msg> = brecv(*); //ricevo
message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me ) {
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
break; //esci dal while
else //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

User:LiberaL

2023-05-26T12:52:59Z

LiberaL:

Se vuoi contattarmi sono presente su Telegram con tag [https://t.me/LLibera @LLibera]

Sono Libera Longo, studentessa Laurea Triennale informatica qui a Bologna :D

User:LiberaL

2023-05-26T12:52:28Z

LiberaL:

Se vuoi contattarmi sono presente su Telegram con tag [https://t.me/LLibera @LLibera]

Sono Libera Longo, studentessa Laurea Triennale informatica qui a Bologna :D

(se vedi una pagina firmata con [ https://t.me/llibera LiberaL ] o [ https://t.me/llibera LLibera ] sono sempre io... che non so come firmarmi...)

User:LiberaL

2023-05-26T12:46:09Z

LiberaL:

Se vuoi contattarmi sono presente su Telegram con tag [https://t.me/LLibera @LLibera]

Sono Libera Longo, studentessa Laurea Triennale informatica qui a Bologna :D

User:LiberaL

2023-05-26T12:45:50Z

LiberaL:

Se vuoi contattarmi sono presente su Telegram con tag [https://t.me/LLibera @LLibera]

Sono Libera Longo, studentessa Laurea Triennale informatica qui a Bologna :D anno scolastico 2022/2023

User:LiberaL

2023-05-26T12:45:37Z

LiberaL: Created page with "Se vuoi contattarmi sono presente su Telegram con tag [https://t.me/LLibera @LLibera] Sono Libera Longo, studentessa Laurea Triennale informatica qui a Bologna :D anno scolast..."

Se vuoi contattarmi sono presente su Telegram con tag [https://t.me/LLibera @LLibera]
Sono Libera Longo, studentessa Laurea Triennale informatica qui a Bologna :D anno scolastico 2022/2023

Prove scritte 2017

2023-05-26T12:37:50Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [https://t.me/LLibera LLibera] 14:26, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo (LLibera) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, pid_t, msg_type> db;
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;

if( ( <dst, mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;
do {
<dst, mit, msg> = brecv(*); //ricevo
bool message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me ) {
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
break; //esci dal while
else //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<dst, mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-26T12:26:45Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [https://t.me/LLibera LLibera] https://t.me/LLibera 14:26, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo (LLibera) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, pid_t, msg_type> db;
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente, ovvero mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//db.get(ANY) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;

if( ( <dst, mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;
do {
<dst, mit, msg> = brecv(*); //ricevo
bool message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me ) {
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
break; //esci dal while
else //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<dst, mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-26T12:19:25Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [https://t.me/LLibera LLibera] 13:41, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo (LLibera) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, pid_t, msg_type> db;
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente precedentemente, mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//se sender è ANY db.get(sender) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;

if( ( <dst, mit, msg> = db.get(sender) ) != NULL ) //se lo trova
return msg;
do {
<dst, mit, msg> = brecv(*); //ricevo
bool message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me ) {
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
break; //esci dal while
else //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<dst, mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-26T12:18:04Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [https://t.me/LLibera LLibera] 13:41, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo (LLibera) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, pid_t, msg_type> db;
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente precedentemente, mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//se sender è ANY db.get(sender) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;

if( ( <dst, mit, msg> = db.get(sender) ) != NULL ) //se non lo trova
return msg;
do {
<dst, mit, msg> = brecv(*); //ricevo
bool message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me ) {
if ( mit == sender || sender == ANY ) //se devo ritornare il messaggio
break; //esci dal while
else //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<dst, mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-26T12:09:53Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [https://t.me/LLibera LLibera] 13:41, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo (LLibera) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, pid_t, msg_type> db;
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente precedentemente, mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//se sender è ANY db.get(sender) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;

if( ( <dst, mit, msg> = db.get(sender) ) != NULL ) //se non lo trova
return msg;
do {
<dst, mit, msg> = brecv(*); //ricevo
bool message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me && ( mit == sender || sender == ANY ) ) //se devo ritornare il messaggio
break; //esci dal while
if( sender != ANY && message_for_me ) { //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<dst, mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-26T12:07:54Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [https://t.me/LLibera LLibera] 13:41, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo (LLibera) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, pid_t, msg_type> db;
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente precedentemente, mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//se sender è ANY db.get(sender) ritorna (ed elimina da db) il primo che trova (FIFO), e if(db.isEmpty()) return NULL;

if( ( <dst, mit, msg> = db.get(sender) ) != NULL ) //se non lo trova
return msg;
do {
<dst, mit, msg> = brecv(*); //ricevo
bool message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me && ( mit == sender || sender == ANY ) ) //se il messaggio è del mittente specificato
break; //esci dal while
if( sender != ANY && message_for_me ) { //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<dst, mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-26T12:03:07Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [https://t.me/LLibera LLibera] 13:41, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo (LLibera) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, pid_t, msg_type> db;
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente precedentemente, mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//se sender è ANY db.get(sender) ritorna il primo che trova (FIFO), e if(db.isEmpty()) return NULL;

if( ( <dst, mit, msg> = db.get(sender) ) != NULL ) //se non lo trova
return msg;
do {
<dst, mit, msg> = brecv(*); //ricevo
bool message_for_me = (dst == getpid()); //il messaggio è per me?
if( message_for_me && ( mit == sender || sender == ANY ) ) //se il messaggio è del mittente specificato
break; //esci dal while
if( sender != ANY && message_for_me ) { //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<dst, mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-26T11:52:35Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [https://t.me/LLibera LLibera] 13:41, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo (LLibera) quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, pid_t, msg_type> db;
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente precedentemente, mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//se sender è ANY db.get(sender) ritorna il primo che trova (FIFO)
if( ( <dst, mit, msg> = db.get(sender) ) != NULL )
return msg;
do {
<dst, mit, msg> = brecv(*); //ricevo
bool message_for_me = (dst == getpid()); //il messaggio è per me?
if( mit == sender && message_for_me ) //se il messaggio è del mittente specificato
break;
if( sender != ANY && message_for_me ) { //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<dst, mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-26T11:50:42Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [https://t.me/LLibera LLibera] 13:41, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, pid_t, msg_type> db;
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente precedentemente, mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//se sender è ANY db.get(sender) ritorna il primo che trova (FIFO)
if( ( <dst, mit, msg> = db.get(sender) ) != NULL )
return msg;
do {
<dst, mit, msg> = brecv(*); //ricevo
bool message_for_me = (dst == getpid()); //il messaggio è per me?
if( mit == sender && message_for_me ) //se il messaggio è del mittente specificato
break;
if( sender != ANY && message_for_me ) { //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<dst, mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-26T11:44:25Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da [https://t.me/LLibera LLibera] 13:41, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, pid_t, msg_type> db;
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente precedentemente, mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//se sender è ANY db.get(sender) ritorna il primo che trova (FIFO)
if( ( <dst, mit, msg> = db.get(sender) ) != NULL )
return msg;
do {
<dst, mit, msg> = brecv(*); //ricevo
bool message_for_me = (dst == getpid()); //il messaggio è per me?
if( mit == sender ) //se il messaggio è del mittente specificato
break;
if( sender != ANY && message_for_me ) { //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<dst, mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-26T11:43:11Z

LiberaL: /* Soluzione proposta 2 */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da [https://t.me/LLibera LLibera] e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da 13:41, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, pid_t, msg_type> db;
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente precedentemente, mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//se sender è ANY db.get(sender) ritorna il primo che trova (FIFO)
if( ( <dst, mit, msg> = db.get(sender) ) != NULL )
return msg;
do {
<dst, mit, msg> = brecv(*); //ricevo
bool message_for_me = (dst == getpid()); //il messaggio è per me?
if( mit == sender ) //se il messaggio è del mittente specificato
break;
if( sender != ANY && message_for_me ) { //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<dst, mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-26T11:41:45Z

LiberaL: /* Esercizio c.2 (da controllare) */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da Libera e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da 13:41, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, pid_t, msg_type> db;
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente precedentemente, mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//se sender è ANY db.get(sender) ritorna il primo che trova (FIFO)
if( ( <dst, mit, msg> = db.get(sender) ) != NULL )
return msg;
do {
<dst, mit, msg> = brecv(*); //ricevo
bool message_for_me = (dst == getpid()); //il messaggio è per me?
if( mit == sender ) //se il messaggio è del mittente specificato
break;
if( sender != ANY && message_for_me ) { //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<dst, mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2017

2023-05-26T11:37:57Z

LiberaL: /* gestione arecv(mittente) 17/07/2017 */

== Esame 11/09/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.09.11.tot.pdf 2017.09.11.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor crossing

ok2dir[4]; //NESW
bool busy = false;

pe entra(int dir)
if (busy)
ok2dir[dir].wait();
busy = true;

pe esci(int dir)
busy = false;
ok2dir[(dir + 1) % 4].signal();
if (!busy)
ok2dir[(dir + 2) % 4].signal();
if (!busy)
ok2dir[(dir + 3) % 4].signal();
if (!busy)
ok2dir[(dir + 4) % 4].signal(); //dir

//alternativa più compatta
pe esci(int dir)
busy = false;
for (i = 0; i < 4; i++)
if (!busy)
ok2dir[(dir + i + 1) % 4].signal();

</syntaxhighlight>
 

==== Soluzione proposta 2 ====
Soluzione proposta da Libera e corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]

<syntaxhighlight lang=C>

const int N_DIRECTION = 4;

// assumo N = 0, E = 1, S = 2, W = 3, oppure shiftati ciclicamente, è equivalente

monitor crossing {
bool free; //l'incrocio è libero?
int num_waiting[N_DIRECTION];
condition okToCross[N_DIRECTION]; //free == True

crossing() {
free = True; //parto con l'incrocio libero
for (int i = 0; i < N_DIRECTION; i++) {
num_waiting[i] = 0;
}
}

procedure entry enter(int direction) {
if(!free) { //se l'incrocio non è libero
num_waiting[direction]++;
okToCross[direction].wait(); //aspetto nella mia direzione
num_waiting[direction]--;
}
//ora sono sicurə che sia libero
free = False; //quindi lo dichiaro occupato
}

procedure entry exit(int direction) {
//non devo aspettare niente per liberare l'incrocio
free = True; //lo dichiaro libero

for (int i = 0; i < N_DIRECTION; i++) {
int curr_dir = (direction + i + 1) % N_DIRECTION;
if (num_waiting[curr_dir] > 0) {
okToCross[curr_dir].signal();
break; // l'onere di risvegliare gli altri è stato passato al nuovo processo risvegliato, quindi esco.
}
}
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
<syntaxhighlight lang="c">
// server[] = array contenente il PID di tutti i server

#define BROADCAST server[0]

server[0]
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto da me stesso allora lo stampo
else
asend(*, <msg, getpid()>); // se il messaggio l'ho ricevuto da un client o da un altro server lo inoltro a tutti i server (compreso me stesso)
}
}

server[x] // x = 1...N-1
{
while(true)
{
<msg, sender> = arecv(*); // ricevo il messaggio
if (sender == BROADCAST)
print(msg); // se il messaggio l'ho ricevuto dal server[0] allora lo stampo
else
asend(BROADCAST, <msg, getpid()>) // se il messaggio l'ho ricevuto da un client lo inoltro al server[0]
}
}
</syntaxhighlight>
 

==== Soluzione proposta 2 ====

Soluzione proposta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Flecart Flecart]
Soluzione corretta da [https://so.v2.cs.unibo.it/wiki/index.php/User:Gio Flecart friend]

<syntaxhighlight lang=C>
process server_0 {

while (true) {
<msg, sender> = arecv(ANY);
for (int i = 1 ; i < N; i++) {
asend(<msg, 0>, server[i]);
while(true){
msg = arecv(server[i]); // così so che tutti abbiano stampato.
if(msg==ACK)
break
asend(msg,server[0]);
}
}
print(msg);
}
}

process server_[i=1 to N - 1] {
while (true) {
<msg, sender> = arecv(ANY);
if (sender == 0) {
print(msg);
asend(ACK, server[0]);
} else {
asend(<msg, i>, server[0]);
}
}
}

</syntaxhighlight>

== Esame 17/07/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.07.17.tot.pdf 2017.07.17.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor conf {
condition finished;
condition ready2present[max];
bool arrived[max] = false;
bool giachiamato[max] = false;

entry chiama(chiamato){
if(arrived[chiamato] == true)
ready2present[chiamato].signal;
finished.wait;
return true;
else
giachiamato[chiamato]= true
return false;
}

entry arrivato(nome){
if(giachiamato[nome] == true)
return false;

arrived[nome] = true;
ok2present[nome].wait;
return true;
}

entry finepresentazione(nome){
finished.signal;
}
}

</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
controllata da 13:37, 26 May 2023 (CEST) l'implementazione fornita gestisce solo il caso di arecv(ANY) e non arecv(mittente)
<syntaxhighlight lang="c">
si, è possibile:

Implementare asend e arecv date bsend e brecv

asend(pid_t dst, msg_type msg){
bsend (<dst, msg>);
}

arecv(*){
do {
<dst, msg> = brecv(*);
} while (dst != getpid())
return msg;
}
</syntaxhighlight>
 
propongo quindi questa implementazione con gestione arecv da mittente specificato (sempre da controllare)
<syntaxhighlight lang="c">
//il messaggio mandato è la tripla <destinatario, mittente, messaggio>

asend(pid_t dst, msg_type msg){
bsend (<dst, getpid(), msg>);
}

Queue of <pid_t, pid_t, msg_type> db;
arecv(pid_t sender) {

//devo controllare se nella coda ho già ricevuto il messaggio da quel mittente precedentemente, mentre aspettavo un messaggio da qualcun'altro
//db.get(sender) cerca una tripla il cui mittente è sender
//se trova il messaggio lo rimuove anche dal db.
//se sender è ANY db.get(sender) ritorna il primo che trova (FIFO)
if( ( <dst, mit, msg> = db.get(sender) ) != NULL )
return msg;
do {
<dst, mit, msg> = brecv(*); //ricevo
bool message_for_me = (dst == getpid()); //il messaggio è per me?
if( mit == sender ) //se il messaggio è del mittente specificato
break;
if( sender != ANY && message_for_me ) { //se devo salvarlo (sender specificato e messaggio per me)
//devo mettere in db i messaggi di altri mittenti, ricevuti quando ne aspettavo uno da un mittente specificato
db.add(<dst, mit, msg>);
}
} while (!message_for_me)
return msg;
}
</syntaxhighlight>
 

== Esame 19/06/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.06.19.tot.pdf 2017.06.19.tot.pdf]
=== Esercizio c.1 (da controllare)===

* Mi sembra che ci sia un errore per il giodice, potrebbe succedere in un caso che il wait non si risvegli mai [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 15:38, 19 January 2023 (CET)

<syntaxhighlight lang="c">
#define NATLETI n

condition ok2lancia[NATLETI];
condition ok2giudice;

int counter[NATLETI];
int ultimo_tiro;
float registro[NATLETI][3];

Procedure entry: boolean pronto(int i)
{
if(!(i == 0 && counter[i] == 0)) // se è il primo lancio non devo metterlo in wait
ok2lancia[i].wait()
if(counter[i] < 3)
return true;
else
return false;
}

Procedure entry: void lanciato (int i)
{
counter[i]++;
ultimo_tiro = i;
ok2giudice.signal();
}

Procedure entry: int lanciofatto()
{
ok2giudice.wait()
if(ultimo_tiro == NATLETI-1 && counter[0] == 3)
return -1; // devo invalidare la condizione per uscire dal while, quindi se nessuno deve più lanciare ritorno -1
else
return ultimo_tiro;
}

Procedure entry: void registraechiama(int i, float m)
{
registro[i][counter[i]-1] = m; // il secondo indice indica l'iesimo lancio -1 (perchè iniziamo a contare da zero)
if(i == NATLETI-1) // se ha appena tirato l'ultimo atleta non posso dare il via a NATLETI (perchè non esiste), quindi faccio ricominciare il giro
ok2lancia[0].signal();
else
ok2lancia[i+1].signal();
}

Procedure entry: int classifica()
{
int best[NATLETI];
for(int i = 0; i < NATLETI; i++)
{
for(int j = 0; j < 3; j++)
{
if(registro[i][j] > best[i])
best[i] = registro[i][j];
}
}
best.sort_in_descending_order(); // supponiamo nel nostro pseudolinguaggio esista una funzione di ordinamento qualunque
return best;
}
</syntaxhighlight>
 

== Esame 29/05/2017 ==
[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 2017.05.29.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
condition okpartita
condition ok2chiama
condition ok2punteggio
condition ok2run[2][MAX]
int numpronti
int punteggio[2]
boolean partita=false
boolean partitafinita=false
chiamati = []
contabandiera[2]
int winner

entry nuovapartita():
{
punteggio[A] = punteggio[B] = 0;
numpronti = 0;
partita=true;
okpartita.signal()
chiamati = [];
}
entry chiama(l):
{
if (numpronti<2*MAX)
{
ok2chiama.wait();
}
chiamati = l;
contabandiera[A] = contabandiera[B] = 0
winner = -1;
for (s in n)
{
ok2run[A][s].signal();
ok2run[B][s].signal()
}
ok2punteggio.wait();
punteggio[winner++]
if (max(punteggio) == 10)
{
partitafinita = true;
for (s in A,B)
{
for (n in range(MAX))
{
ok2run[s][n].signal();
}
}
}
return punteggio;
}
entry pronto(s, n):
{
if (partitafinita) return 1;
if (!partita)
{
okpartita.wait();
}
numpronti++;
if (numpronti>=2*MAX)
{
ok2chiama.signal();
}
if (!(n in chiamati))
{
ok2run[s][n].wait();
}
numpronti--;
return 0 if partita else 1;
}
allabandiera(s, n):
{
contabandiera[s]++;
if (winner == -1 && contabandiera[s] == len(chiamati))
{
winner = s;
}
if (contabandiera[A] == len(chiamati) && contabandiera[B] == len(chiamati))
{
ok2punteggio.signal();
}
}

casi da discutere:
se arrivano studenti a pronto prima che il prof dichiara nuovapartita succedono guai.
</syntaxhighlight>

Prove scritte 2018

2023-05-12T15:00:06Z

LiberaL: /* Soluzione "schiacciasassi" */

= Esame 19/09/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.09.19.tot.pdf Testo dell'esame].

=== Esercizio c.2 (da controllare) ===

* Controllato dall'utente ? in data ?
* ...

Nello pseudocodice seguente, il termine this fa riferimento al processo corrente, mentre ANY ad uno qualunque.

<syntaxhighlight lang="c">
stack<message> messages;

void lifo_send(string m, process dest) {
do {
asend(m, dest);
} while (areceive(dest).text != "ACK");
}

message lifo_receive(process source) {
if (source != ANY) {
message m = areceive(source);

asend("ACK", source);

return m;
} else {
message m;

asend("END", this);
m = areceive(ANY);

while (m.text != "END" || m.sender != this) {
messages.push(m);
asend("ACK", m.sender);

m = areceive(ANY);
}

/* Bisogna tenere conto dei casi in cui lifo_receive() viene invocata quando nessun
* messaggio è stato ancora spedito da altri processi. In tal caso si attende il
* il primo e lo si restituisce.
*/
if (messages.empty()) {
m = areceive(ANY);
asend("ACK", m.sender);

return m;
} else {
return messages.pop();
}
}
}
</syntaxhighlight>

= Esame 17/07/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.07.17.tot.pdf 2018.07.17.tot.pdf]
== Esercizio c.1 ==
A Bruxelles c'è un locale chiamato Delirium Café. Alla vigilia del FOSDEM tutti gli anni gli sviluppatori europei di
software libero si ritrovano a bere birra (il locale è nel guinnes dei primati con più di duemila tipi di birra). Il prossimo appuntamento è
fissato per il 1 febbraio 2019 ore 20. Numerosi sono i tipi di birra alla spina. I baristi (tanti) prendono gli ordini (es. mezza pinta, 1 o 2
pinte) e riempiono i bicchieri. Quando un fusto e' vuoto avvertono i magazzinieri che prendono un nuovo fusto che contiene più di
cento pinte e lo sostituiscono, a questo punto il barista può completare il riempimento del bicchiere.
La vita di un barista del Delirium è:
while True:
(type, quantity) = get_order()
delirium.pour(type, quantity)
La vita di un Magazziniere è:
while True:
type = delirium.isempty()
capacity = change_keg(type)
delirium.loaded(type, capacity)

Attenzione: se il fusto (keg) è quasi vuoto il barista dovrà riempire parzialmente il bicchiere, occorrerà attivare il magazziniere che
cambierà il fusto e poi il barista riempirà il bicchiere fino alla quantità richiesta dal cliente. Mentre un barista sta attendendo il
cambiamento di un fusto altri baristi potrebbero ricevere ordini per lo stesso tipo di birra: gestire opportunamente questo caso.
Scrivere il monitor Delirium.

=== Proposta di soluzione 1 ===
* ERRORE: Secondo me c'è un leggero errore nella parte di load, nel caso in cui la nuova pinta non riesca a soddisfare completamente la richiesta ossia quando vale availableBeer[t] <= requests[t].head(), allora non lo risveglio nemmeno, invece dovrei risvegliare il pour, fargli versare quanto può, e richiedere una altra pinta, perché questo era un requisito del problema. [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 12:00, 15 January 2023 (CET)

<syntaxhighlight lang="c">
/* Monitor Delirum: */

// Condition: Ok2Load;
// Condition: Ok2Pour[]; // Un elemento per Type
int availableBeer[]; // Un elemento per Type
Queue requests[]; // Un elemento per Type
Queue pendingRequests;

Procedure entry: void Pour(Type t, Quantity c)
{
if (c > availableBeer[t]) // Richiesta maggiore della birra disponibile
{
c -= availableBeer[t];
availableBeer[t] = 0;
requests[t].Enqueue(c);
if (requests[t].Length == 1) // Risveglio un magazziniere solo se è la prima richiesta di questo tipo di birra
{
pendingRequests.Enqueue(t);
Ok2Load().Signal();
}
Ok2Pour[t].Wait();
requests[t].Dequeue(); // Quando ho ottenuto la birra che voglio, elimino la mia richiesta
}
availableBeer[t] -= c;
}

Procedure entry: Type isEmpty()
{
if (pendingRequests.Length == 0)
{
Ok2Load.Wait();
}
return pendingRequests.Dequeue();
}

Procedure entry: Loaded(Type t, Capacity c)
{
availableBeer[t] += c;
while (requests[t].Length > 0 && availableBeer[t] > requests[t].head())
{
Ok2Pour[t].Signal();
}

if (requests[t].Length > 0) // serve per evitare che a causa di un magazziniere lento si accodino cosi tante richieste che mentre si sta caricando si svuota subito il fusto
{
pendingRequests.Enqueue(t);
Ok2Load.Signal();
}
}
</syntaxhighlight>

=== Proposta di soluzione 2 ===
* Proposto da [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 13:41, 15 January 2023 (CET)
<syntaxhighlight lang="C">
extern int MAX_TYPE;
class Delirium {
int keg[MAX_TYPE]; // qnty fusto attuale
int orders[MAX_TYPE]; // qnty richiesta
bool worked[MAX_TYPE]; // 1 se magazziniere sta lavorando su questo.

condition type_wait[MAX_TYPE];
int num_wait[MAX_TYPE];

queue<int> empty_type;
condition is_empty;

entry pour(type, quantity) {
while (keg[type] < quantity) {
quantity -= keg[type];
keg[type] = 0;
if (!empty_type.find(type) && !worked[type]) {
empty_type.enqueue(type);
is_empty.signal();
}

num_wait[type]++;
type_wait[type].wait();
num_wait[type]--;
}
keg[type] -= quantity;
quantity = 0; // questo è inutile, ma concettualmente è corretto, l'ordine è completato.
}

entry loaded(type, capacity) {
keg[type] += capacity;
worked[type] = false;

for (int i = num_wait[type]; i > 0; i--) {
type_wait[type].signal();
}
}

// si suppone che un singolo tipo di fusto è lavorabile da un solo magazziniere alla volta.
// worked impedisce di avere nella coda un fusto su cuisi sta già lavorando.
entry isempty() {
if (empty_type.size() <= 0) {
is_emtpy.wait();
}
int type = emtpy_type.dequeue();
worked[type] = true;
return type;
}
}
</syntaxhighlight>

== Esercizio c.2 ==

=== Proposta di soluzione 1 ===
* Visto e corretto dall'utente [[User:Acsor|Acsor]] in data 23/08/2020
* Visto e corretto dall'utente ? in data ?
* Visto, ritenuto corretto [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 09:27, 15 January 2023 (CET)

<syntaxhighlight lang="c">
class LIFOBuffer {
stack<T> s;
semaphore mutex(1); // mutua esclusione
semaphore ok2consume(0);

void push (T value) {
mutex.P();
s.push(value);
// (1)
mutex.V()

ok2consume.V() // Curiosità: che succede se spostiamo quest'istruzione in (1)? Edit: funziona lo stesso, solo che aggiorni il valore del semaforo prima di uscire dalla mutex.
}

T pop () {
T value;

ok2consume.P();
mutex.P();
value = s.pop();
mutex.V();

return value;
}
}
</syntaxhighlight>

=== Proposta di soluzione 2 ===
Proposto da [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 09:27, 15 January 2023 (CET)

<syntaxhighlight lang="C">
class lifobuf {
semaphore mutex(1);
stack<int> values; // empty initialized
stack<semaphore> waiting;

push(int value) {
mutex.P();
values.push(value);
if (waiting.size() > 0) {
semaphore s = waiting.pop();
s.V();
return;
}

mutex.V();
}

pop() {
int ret_val;
mutex.P();
if (values.size() <= 0) {
semaphore s = new semaphore(0);
waiting.push(s);
mutex.V();
s.P();
free(s);
}

ret_val = values.pop();
mutex.V();

return ret_val;
}
}
</syntaxhighlight>

== Esercizio g.1 ==
Possiamo notare subito che il sistema ha due processori ed un dispositivo di I/O.
'''A''' e '''B''' partono insieme al tempo 0. 
'''C''' parte tra il tempo 0 ed il tempo 2 (non possiamo sapere di preciso quando perchè entrambe le CPU sono occupate). 
'''D''' parte tra il tempo 0 ed il tempo 3. 
A questo punto possiamo supporre che tutti e 4 i processi partano in sequenza ('''A''', '''B''', '''C''', '''D''') nello stesso momento, e ognuno prende la prima CPU libera che trova. 
'''A''' lavora per 3ms, poi scade il time slice. 
Nel frattempo '''B''' lavora per 2ms, poi richiede I/O per 4ms. 
La CPU su cui lavora '''B''' quindi si libera, e si manda in esecuzione il processo '''C'''. 
Scaduto il time slice per '''A''', si da il controllo ad un nuovo processo. '''B''' è occupato con I/O, '''C''' sta già lavorando, quindi è il turno di '''D'''. 
'''C''' lavora per 3ms, poi richiede I/O per 3ms, che però è occupato da '''B''', quindi si mette in coda per utilizzarlo. 
La CPU su cui lavorava '''C''' si libera ed il controllo torna ad '''A''', che doveva lavorare ancora per 2ms prima di chiedere il controllo di I/O, quindi lavora e si mette in coda dietro a '''C'''. 
Tornando a '''D''', questo lavora per 3ms prima che scada il time slice. Anche '''B''' ha finito il lavoro e ha bisogno di una CPU. 
In questo momento sia '''D''' che '''B''' sono nella coda dei processi in stato ready, ma dal diagramma possiamo notare che il controllo torna a '''D'''. 
La CPU ha scelto a caso un processo tra i due, perchè arrivati a questo punto possiamo supporre che lo scheduler sia Round-Robin. 
'''B''' prende possesso della prima CPU che si libera, ovvero quella occupata da '''A''', poi lavora per 2ms e termina il suo lavoro. 
Nel momento in cui '''B''' termina il lavoro, scade anche il time slice per '''D''', e '''C''' termina di usare I/O. 
Abbiamo due processi ('''C''' e '''D''') in coda ready. Ma abbiamo anche due CPU libere, perchè '''A''' è in coda per I/O e ci entra appena '''C''' finisce di usarlo. 
Lo scheduler sceglie di mandare '''C''' sul primo processore e '''D''' sul secondo. 
'''A''' nel frattempo, lavora per 4ms con I/O. 
'''C''' lavora per 3ms, poi termina il suo lavoro. 
'''D''' lavora per 3ms, poi scade il time slice. Ci sono due processori liberi, quindi '''D''' riparte subito in esecuzione. 
'''D''' doveva lavorare ancora per 1ms prima di aver bisogno di I/O, quindi finisce e si mette in coda. 
Ma nello stesso momento '''A''' termina di usare I/O, si prende un processore libero e lavora per i suoi ultimi 2ms. 
'''D''' lavora per 1ms con I/O, poi prende il secondo processore libero e lavora per 1ms prima di terminare il suo lavoro. 

Il time slice è di 3ms, lo scheduler è di tipo Round-Robin. 
Il dispositivo di I/O è FIFO. L'ordine con cui partono i processi è quello alfabetico.

<syntaxhighlight lang="c">
A(){
compute_a1(); // 5ms
io_a(); // 4ms
compute_a2(); // 2ms
}

B(){
compute_b(); // 2ms
io_b(); // 4ms
compute_b(); // 2ms
}

C(){
compute_c(); // 3ms
io_c(); // 3ms
compute_c(); // 3ms
}

D(){
compute_d1(); // 10ms
io_d(); // 1ms
compute_d2(); // 1ms
}
</syntaxhighlight>
Lo scheduler potrebbe anche essere a priorità: 
Priorità '''B''' < priorità '''D''' < priorità '''C''' 
Priorità '''A''' = ? 
'''B''' fatto partire prima di '''C''' e '''D'''.
 

== Esercizio g.2 (da controllare) ==
# In sistemi dove dispositivi di archiviazione o supporti hardware per la memoria virtuale (e dunque per la paginazione, spesso utilizzata per realizzare il supporto di memoria virtuale) non sono presenti (es. sistemi embedded). ''(In sistemi real-time la memoria virtuale è praticabile? Annotare.)''
# Perchè ad esempio sulle chiavette USB quasi mai abbiamo il problema di dover utilizzare file di dimensione maggiore ai 4GB. Non utilizza il journaling, che richiede molteplici scritture per ogni azione ed in dispositivi portatili può ridurre di molto la durata. Non supporta i permessi sui file, e questo è un vantaggio per le chiavette USB, pensate per trasferire dati tra PC diversi.
# Per fornire parallelismo e ridondanza. Non è necessario fare backup dei dati sul disco, nel senso di mantenere una copia identica di dati già memorizzati altrove, in quanto diversi sistemi di codici permettono il rilevamento e/o la correzione di errori.
# Se in un grafo di Holt multirisorsa esiste un ciclo tra più processi e risorse, ciò non significa che allo stesso tempo non siano coinvolti processi con archi esclusivamente entranti. Ogni processo appartenente a questa categoria non è in attesa di risorse, e può dunque procedere con i suoi calcoli; quando avrà terminato rilascerà le risorse precedentemente allocategli, eventualmente sbloccando uno dei processi coinvolti nel ciclo.

= Esame 21/06/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.06.21.tot.pdf 2018.06.21.tot.pdf]
=== Esercizio c.1 (sbagliato) ===
<syntaxhighlight lang="c">
/* Monitor tmon */

define MAX n;
define TERRAFERMA 1;
define ISOLA 2;

semaphore ok2unload;
semaphore ok2load;
semaphore ok2ship;
semaphore mutex(1); // la rampa è zona critica --> mutua esclusione

stack ferry;
int current_port = 0;

Procedure entry: al_porto(int location)
{
current_port = location; // traghetto arriva a destinazione
ok2unload.signal(); // da il via per far sbarcare le macchine
ok2ship.wait(); // si ferma
current_port = 0; // traghetto sta viaggiando tra i due porti
}

Procedure entry: imbarca(int location)
{
mutex.wait(); // prende possesso della rampa
ferry.push(1); // sale sul traghetto
mutex.signal(); // libera la rampa
}

Procedure entry: imbarcato(int location)
{
if(ferry.lenght() == MAX) // se il traghetto è pieno da il via per farlo salpare
{
ok2load.wait();
ok2ship.signal();
}
}

Procedure entry: sbarca(int location)
{
mutex.wait(); // prende possesso della rampa
ferry.pop(); // scende dal traghetto
mutex.signal(); // libera la rampa
}

Procedure entry: sbarcato(int location)
{
if(ferry.lenght() == 0) // se il traghetto è vuoto da il via per far imbarcare le macchine
{
ok2unload.wait();
ok2load.signal();
}
}

</syntaxhighlight>
 

=== Esercizio c.1 ===
<syntaxhighlight lang="c">
/* Monitor tmon */

#define MAX n
#define NONE 0
#define TERRAFERMA 1
#define ISOLA 2

condition ok2unload;
condition ok2load[2];
condition ok2ship;
condition empty;

int onboard = 0;
int onramp = 0;
int current_port = NONE;

Procedure entry: al_porto(int location)
{
//arrivando
current_port = location;
ok2unload.signal();
if (onboard > 0)
empty.wait()
ok2load[location].signal()
if (onboard < MAX)
ok2ship.wait()
//partendo
current_port = NONE;
}

Procedure entry: imbarca(int location)
{
if (current_port != location || onramp > 0 || onboard >= MAX)
ok2load[location].wait()
onramp = 1;
}

Procedure entry: imbarcato(int location)
{
onramp = 0; onboard++;
if (onboard < MAX)
ok2load[location].signal();
else
ok2ship.signal();
}

Procedure entry: sbarca(int location)
{
if (current_port != location || onramp > 0)
ok2unload.wait()
onramp = 1;
}

Procedure entry: sbarcato(int location)
{
onramp = 0; onboard--;
if (onboard == 0)
empty.signal();
else
ok2unload.signal();
}
</syntaxhighlight>
 

=== Esercizio c.2 (sbagliato) ===
<syntaxhighlight lang="c">

#define N n // limite operazioni
semaphore mutex(1); // sezione critica

class lim_semaphore()
{
int value;
semaphore plus;
semaphore minus;

P()
{
mutex.P();
if(value < N)
{
if (value >= 0)
{
plus.P();
}
else
{
minus.V();
}
value--;
}
mutex.V();
}

V()
{
mutex.P();
if(value > -N)
{
if (value <= 0)
{
minus.P();
}
else
{
plus.V();
}
value++;
}
mutex.V();
}
}
</syntaxhighlight>
 

=== Esercizio c.2 ===
==== Soluzione "furba e facile" ====
* Visto dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]) in data 18:53, 9 September 2020 (CEST). Ritengo sia: corretto (perché l'ho fatto pressappoco uguale). (Ritengo anche che possedere strumenti di analisi formale per verificare la correttezza di codice simile sarebbe di grande ausilio.)

<syntaxhighlight lang="java">
class bounded_semaphore {
semaphore plus;
semaphore minus;
int value; // serve per significato

bounded_semaphore (int initval, unsigned maxval) {
value = initval;
plus = new semaphore(maxval + initval);
minus = new semaphore(maxval - initval);
}

void P() {
plus.P();
value--;
minus.V();
}

void V() {
minus.P();
value++;
plus.V();
}
}
</syntaxhighlight>

==== Soluzione "schiacciasassi" ====
visto da [https://t.me/llibera LiberaL] in data 2023/05/12, perchè nel primo if della V() si fa value >= - maxval? non dovrebbe essere + maxval?

<syntaxhighlight lang="java">
class bounded_semaphore {
semaphore mutex;
queue<semaphore> okmin, okmax;
int value;
unsigned maxval;

bounded_semaphore (int initval, unsigned maxval) {
value = initval;
this.maxval = maxval;
}

void P() {
mutex.P();

if (value <= -maxval) {
s=semaphore(0);
okmin.enqueue(s);
mutex.V();
s.P();
} else if (okmax.length() > 0) {
s = okmax.dequeue()
s.V();
mutex.V();
} else {
value--;
mutex.V();
}
}

void V() {
mutex.P();

if (value >= -maxval) { //qui...
s=semaphore(0);
okmax.enqueue(s);
mutex.V();
s.P();
} else if (okmin.length() > 0) {
s = okmin.dequeue()
s.V();
mutex.V();
} else {
value++;
mutex.V();
}
}
}
</syntaxhighlight>

=== Esercizio g.1 ===
* Controllato dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]), 23:17, 9 September 2020 (CEST). Ritengo sia: corretto

<nowiki>
IC = 10,10,10 // Capitale iniziale
COH = 4,4,4 // Saldo in cassa

MAX ATT RES AVAIL
P1 | 6,6,6 | 1,1,1 | 5,5,5 | 4,4,4
P2 | 6,6,6 | 1,1,1 | 5,5,5 | 5,5,5
P3 | 9,9,9 | 4,4,4 | 5,5,5 | 6,6,6
</nowiki>

Minimizzato

<nowiki>
IC = 4,4,4
COH = 1,1,1

MAX ATT RES
P1 | 3,3,3 | 1,1,1 | 2,2,2
P2 | 3,3,3 | 1,1,1 | 2,2,2
P3 | 3,3,3 | 1,1,1 | 2,2,2
</nowiki>

=== Esercizio g.2 (da controllare) ===

* Visto e rimaneggiato in data 19:40, 10 September 2020 (CEST) dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]])

<hr>

# Il calcolo del working set serve a determinare il numero di processi che possono essere mantenuti attivi sulla base del limite della memoria principale, più precisamente del suo numero di frame. Può essere svolto ad ogni page fault, ossia quando un processo tra quelli attivi richiede una pagina non presente in memoria, o prima di avviare un nuovo processo.
# La lunghezza massima di un file che può essere memorizzato su un file system di tipo FAT viene calcolata moltiplicando il massimo numero di cluster (dimensione dell'unità di allocazione) identificabili per la loro dimensione. Il massimo numero di cluster identificabili dipende da quanti bit sono allocati per numerarli, e per questa distinzione esistono varie versioni di FAT (FAT12, FAT16, FAT32).
## FAT32 memorizza la dimensione dei file in un intero unsigned da 32bit, e non può quindi gestire un file di dimensione superiore ai 2^32 bit = ~4GB.
## FAT16, allocando 16bit per identificare i cluster, può contarne al massimo 2^16 (65536). Prendendo quindi, ad esempio, un file system FAT16 con cluster da 32KB, possiamo avere file grandi al massimo 32KB*65536 = ~2GB.
## FAT12 di conseguenza può numerare al massimo 2^12 (4096) cluster, ma dato che il numero dei settori del disco viene memorizzato in un intero signed a 16bit, la massima dimensione del disco è 2^15 = 32MB. Ovviamente, non si può memorizzare un file di grandezza superiore alla dimensione dell'unità di memorizzazione stessa, e quindi anche i file in FAT12 possono avere dimensione massima di 32MB.
# Entrambi condividono l'intento di infettare host con codice malevolo, ma differiscono fondamentalmente nella modalità: i virus infettano programmi già esistenti mediante un ''virus dropper'', mentre i worm diffondono copie di se stessi, solitamente attraverso la rete.
# In vari casi sulla base della natura del sistema. Innanzitutto, in sistemi batch ciò avviene se non sono stati inseriti più processi per un certo lasso di tempo. In sistemi general-purpose (es. per PC o dispositivi mobili) tale condizione è verificabile se tutti i processi sono in attesa su una coda che non è quella dello scheduler (ad. es. di un semaforo o di una periferica di I/O); casi concreti sono pertanto il deadlock (di tutti i processi del sistema) o attesa generale di I/O. Infine sempre in sistemi general-purpose tale condizione può manifestarsi, stavolta in condizioni patologiche, se ogni processo è assegnato ad una propria CPU/core, lasciando pertanto la coda d'attesa vuota.

= Esame 28/05/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.05.28.tot.pdf 2018.05.28.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
Stack<int> entriesStack;

int vid[MAX];
condition ok2esci[MAX]
int in = 0;
int out = -1;

Procedure-entry: entra(int id) {
if (in >= MAX)
ok2entra.wait()
vid[in++] = id;
if (in < MAX)
ok2entra.signal()
else
out = MAX - 1;
}

Procedure-entry: esci(int id) {
int i;
for (i = 0; i < in; i++)
if (vid[i] == id)
break; //cerco l'indice di id nel vettore vid

if (i != out)
ok2esci[i].wait();

if (out > 0) {
out--;
ok2esci[out].signal();
} else {
out--;
in = 0;
ok2entra.signal();
}
}
</syntaxhighlight>
 

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">
Monitor riempisvuota {
Int MAXPROCESSI;
Stack s;
condition ok2enter;
condition ok2exit;

p.e void entra(getPid()){
if( s.size() >= MAXPROCESSI)
ok2enter.wait();
s.insert(getPid());
if(s.size() > MAXPROCESSI)
ok2exit.signal()
}

p.e void esci(getPid()){
if(s.size() > MAXPROCESSI && s.top == getPid()) {
s.pop();
ok2entra.signal()
}
else
ok2exit.wait();
}
</syntaxhighlight>
 
=== Esercizio c.2 (ERRATO) ===

* Soluzione proposta è errata, non puoi riceve in modo greedy e printare subito il carattere [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 11:33, 18 January 2023 (CET)

<syntaxhighlight lang="c">
proc[x]: x='a',...,'z'
while True:
//c sarà il carattere stampato dal processo precedente
(c, string) = arecv(*)
if(string == wait){
//mi metto in attesa di ricevere l'ACK da proc[x]
m=arecv(x);
}
if (c == NONE){
//significa che sei il primo a ricevere quella stringa
print(x);
if (len(string) > 1){
//mando la wait a tutti, il primo che riceve qualcosa da stampare manda una wait a tutti
asend(wait,*);
int l = len(string);
int i = 1;
while(l != 0){
asend(proc[string[i]], (x, string[i...]));
//si mette in attesa di ricevere l'ACK dal processo dell'ultima lettera della parola
m=areceive(proc[string[i]]);
//rimando la wait al processo per ribloccarlo
asend(wait, proc[string[i]])
l--;
i++;
}
//dopo aver finito la stampa della stringa sblocco tutti i processi
asend(ACK, *);
}
}else{
print(x);
asend(ACK, x);
//ricomincia il ciclo while, si rimette in attesa e il 'gestore gli rimanda la wait'
}
</syntaxhighlight>
 

=== Esercizio c.2 ===
[[User:Flecart|Flecart friend]] ([[User talk:Flecart|talk]]) cedo la proprità intellettuale di questa soluzione a flecart

<syntaxhighlight lang="c">
process [x]: x='a'..'z'
if(x=='a'){
asend(<NULL,NULL>,'b');
asend(<NULL,NULL>,'b');
}
While True:
<c,string>=arecv(x-1+26%26);
if(string==NULL):
<c,string>=arecv(*);
if(string!=NULL):
<c,string>=arecv(x-1+26%26);

if(string!=NULL):
if(string[0]==x):
print(string[0]);
if(string.len()>1):
aasend(<NULL,string[1:]>,(x+1)%26);
else:
aasend(<NULL,NULL>,(x+1)%26);
aasend(<NULL,NULL>,(x+1)%26);
else:
aasend(<NULL,string>,(x+1)%26);
else:
aasend(<NULL,NULL>,(x+1)%26);
aasend(<NULL,NULL>,(x+1)%26);

</syntaxhighlight>

=== Proposta c2 ===
* Proposto [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 11:31, 18 January 2023 (CET)

<syntaxhighlight lang="C">
proc[a]:
bool occupied = false;
queue<string> s;

while True {
(c, string) = arecv(*);

if (c == NONE) {
if (occupied) {
s.enqueue(string);
} else {
if (string.len() < 1)
continue;

occupied = true;
asend(string[0], (MIDDLE, string));
}
} else if (c == END) {
if (s.size() > 0) {
string ss = s.dequeue();
asend(string[0], (MIDLLE, string));
} else {
occupied = false;
}
} else {
print(x);
if (len(string) > 1)
asend(proc[string[0]], (MIDDLE, string[1:]));
else:
asend(proc[a], (END, ""));
}
}

proc[x]: x = 'b', ... 'z';
while True {
(c, string) = arecv(*);
if (c == NONE) {
asend(proc['a'], (NONE, string));
} else { // potrà essere solo MIDDLE
print(x);
if (len(string) > 1)
asend(proc[string[0]], (MIDDLE, string[1:]));
else:
asend(proc[a], (END, ""));
}
}
</syntaxhighlight>

= Esame 12/02/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.02.12.tot.pdf 2018.02.12.tot.pdf]

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">

monitor bridge:

int ncar
bool boat_on_0
bool boat_on_1 // per semplicità, quando nel codice si trova boat_on_(direction) oppure isBoat(direction)(),
// si valuta il valore booleano di direction e lo si applica sotto forma di stringa al simbolo
// ad esso adiacente
bool is_raised
queue waiting_mean // i valori possibili sono: boat0, boat1 oppure car
condition ok2go

entry car_enter(direction):
if is_raised || ncar == MAXCAR:
waiting_mean.enqueue(car)
ok2go.wait()
is_raised = false
++ncar

entry car_exit(direction):
--ncar
if (waiting_mean.top().isBoat() && ncar == 0) || waiting_mean.top().isCar(): // isBoat ritorna true se l'oggetto su cui
waiting_mean.dequeue() // è invocata è boat0 oppure boat1
ok2go.signal()

entry boat_enter(direction):
if !is_raised || boat_on_(direction):
waiting_mean.enqueue(boat)
ok2go.wait()
if waiting_mean.top().isBoat(!direction)():
waiting_mean.dequeue()
ok2go.signal()
is_raised = true
boat_on_(direction) = true

entry boat_exit(direction):
boat_on_(direction) = false
if !boat_on_(!direction):
waiting_mean.dequeue()
ok2go.signal()

</syntaxhighlight>

 

=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor bridge {
int carsOnBridge = 0;
int shipping[2] = {0, 0}; //navi da entrambe le direzioni
int status = NONE; //UP DOWN NONE
int last2pass = 0; //ultimo che ha passato il ponte
int waitingC = 0; //coda delle macchine che aspettano
int waitingS[2] = {0,0}; //navi che stanno aspettando

condition ok2ship[2]
condition ok2drive

entry car_enter(int direction){
if(carsOnBridge >= MAX || status == UP || waitingS[0] + waitingS[1] > 0 ){
waitingC++;ok2drive.wait;waitingC--;}
status = DOWN;
carsOnBridge++
if (carsOnBridge < MAX)
ok2drive.signal(); //vanno tutte le MAX car che stanno aspettando
}
entry car_exit(int direction){
carsOnBridge--
if (waitingS[0] + waitingS[1] == 0)
ok2drive.signal();
if(carsOnBridge == 0){
ok2ship[0].signal(); ok2ship[1].signal();
}
if(carsOnBridge + waitingS[0] + waitingS[1] == 0)
status = NONE
}

entry ship_enter(int direction){
if (bridge = DOWN || shipping[direction] != 0 || waitingC > 0)
{
waitingS[i]++; ok2ship[i].wait(); waitingS[i]--;
}
isBridgeUp = false;
shipping[i] = 1;

entry ship_exit(int direction){
shipping[i] = 0;
if (waitingC == 0)
ok2ship[i].signal()
else if(shipping[1-i] == 0)
ok2drive.signal();
if(carsOnBridge + waitingS[0] + waitingS[1] == 0)
status = NONE
}
</syntaxhighlight>

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">
monitor bridge {

UP=0;
DOWN=1;
bridgeis = DOWN;

bool carAreExiting = false;

condition ok2drive;
condition ok2barca[2];

waitingCar = 0;
carOnBridge = 0;

boatWaiting[2] = {0,0};
boatIsPassing[2] = {false,false}

entry car_enter(direction) {

if (bridgeis == DOWN)
if(carOnBridge == MAXCAR)
waitingCar++;
ok2drive.wait();
waitingCar--;
else if (carAreExiting)
waitingCar++;
ok2drive.wait();
waitingCar--;
else
if (boatIsPassing[0] || boatIsPassing[1])
waitingCar++;
ok2drive.wait();
waitingCar--;
bridgeis = DOWN;

carOnBridge++;
carAreExiting = false;
if(carOnBridge < MAXCAR && !carAreExiting)
ok2drive.signal();

}

entry car_exit(direction) {

carOnBridge--;
carAreExiting = true;

if(carOnBridge == 0)
carAreExiting = false;
if(boatWaiting[0] > 0)
bridgeis = UP;
ok2barca[0].signal();
else if (boatWaiting[1] > 0)
bridgeis = UP;
ok2barca[1].signal();
else
ok2drive.signal();
}

entry boat_enter(direction) {

if (bridgeis == UP)
| if (boatIsPassing[direction] == true)
| | boatWaiting[direction]++;
| | ok2barca.wait();
| | boatWaiting[direction]--;
else
| if (carOnBridge > 0)
| | boatWaiting[direction]++;
| | ok2barca.wait();
| | boatWaiting[direction]--;
| | bridgeis = UP;

boatIsPassing[direction] = true;

if(boatIsPassing[1-direction] == false && boatWaiting[1-direction] > 0)
ok2barca[1-direction].signal();

}

entry boat_exit(direction) {

boatIsPassing[direction] = false;

if (boatIsPassing[1-direction] == false)
if (waitingCar > 0)
bridgeis = DOWN;
ok2drive.signal();
else
if (waitingCar == 0)
ok2barca[direction].signal();

}
</syntaxhighlight>

=== Esercizio c.1 (sbagliato) ===
<syntaxhighlight lang="c">
monitor bridge
condition ok2passCar;
condition ok2passBoat;
condition ok2up;
condition ok2down;
int carOnBridge[2] = 0; //2 sensi di marcia
int boatUnderBridge[2] = 0;
boolean bridge_down = false; //vuol dire che il ponte parte alzato, true ponte abbassato

procedure entry car_enter(direction){
if(bridge_down && carOnBridge[direction] < MAXCAR){
carOnBridge[direction]++;
ok2passCar.signal();
}else if (bridge_down && boatUnderBridge[0] == 0 && boatUnderBridge[1] == 0){
//se non ci sono navi in transito e arriva una macchina abbassa ponte
ok2down.signal();
ok2passCar.signal();
ok2passBoat.wait();
}else{
ok2passCar.wait();
}
}

procedure entry car_exit(direction){
carOnBridge[direction]--;
if(carOnBridge[0] == 0 && carOnBridge[1] == 0){
bridge_down = false;
ok2up.signal();
}else{
ok2up.wait();
}
}

procedure entry boat_enter(direction){
if(!bridge_down && boatUnderBridge[direction] < 1){
boatUnderBridge[direction]++;
ok2passBoat.signal();
}else if(!bridge_down && carOnBridge[0] == 0 && carOnBridge[1] == 0){
ok2up.signal();
ok2passBoat.signal();
ok2passCar.wait();
}else {
ok2passBoat.wait();
}
}

procedure entry boat_exit(direction){
boatUnderBridge[direction]--;
if(boatUnderBridge[0] == 0 && boatUnderBridge[1] == 0){
bridge_down = true;
ok2down.signal();
}else{
ok2down.wait();
}
}
</syntaxhighlight>

=== Esercizio c.1 2o (sbagliato) ===
<syntaxhighlight lang="c">
#define car 1
#define ship 2
#define fromDX 1
#define fromSX 0

monitor bridge {
int carsOnBridge = 0;
int shippingDX = 0; //nave che sta passando dal lato destro
int shippingSX = 0; //nave che sta passando dal lato sinistro
bool isBridgeUp = false;
int last2pass = 0; //ultimo che ha passato il ponte
int waitingS = 0; //navi che stanno aspettando
int waitingC = 0 ; //auto che stanno aspettando

condition ok2ship
condition ok2drive

entry car_enter(int direction){
//un auto si ferma se il numero di auto sul ponte è massimo
//e se l'ultima a passare è stata un auto mentre ci sono navi in attesa
if(carsOnBridge == MAX || isBridgeUp || (last2pass==car && waitingS > 0) ){
waitingC++;
ok2drive.wait;
}
carsOnBridge++;
waitingC--;
}

entry car_exit(int direction){
carsOnBridge--;
last2pass = car;
if(carsOnBridge == 0 && waitingS>0){
isBrigdeUp = true;
ok2ship.signal;
}
}

entry ship_enter(int direction){
//se la barca viene da destra
if(direction == fromDX){
//si ferma anche quando c'è una nave che sta già attraversando nella sua stessa direzione
if (isBridgeup == false || shippingDX || (last2pass==ship && waitingC > 0) ){
waitingS++;
ok2ship.wait;
}
if (waitingS > 0)
waitingS--;
shippingDX = 1;
}
//se la barca viene da sinistra
else if(direction == fromSX){
if (isBridgeup == false || shippingSX || ( (last2pass==ship && waitingC > 0))){
waitingS++;
ok2ship.wait;
}
if (waitingS > 0)
waitingS--;
shippingSX = 1;

}
}

entry ship_exit(int direction){
if(direction == fromDX)
shippingDX = 0;
else if (direction == fromSX)
shippingSX = 0;
last2pass = ship;
if(shippingDX == 0 && shippingSX == 0 && waitingC)
isBrigdeUp == false;
ok2drive.signal;
else if(shippingDX == 0 && shippingSX == 0 && waitingS > 0)
ok2ship.signal;
}
}
</syntaxhighlight>

=== Esercizio c.2 (sbagliato) ===

# (Ri)Controllato dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]) in data 26/08/2020

<syntaxhighlight lang="python">
list printed_msg; # questa è una variabile condivisa che ai fini dell'esercizio non si può utilizzare (message passing)

process server[i]:
while true:
<msg, pid> = arecv(*)

if printed_msg.length == 0 or <msg, pid> is not in printed_msg:
printed_msg.append(<msg,id>)
print(msg)
</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
Nello svolgimento seguente, receiver incapsula l'ambiente privato del processo; _peers rappresenta il vettore di processi "fratelli" ai quali può essere chiesto di stampare un messaggio, mentre _printed contiene l'hash di tutti i messaggi stampati dal processo locale. Si suppone che istanze della classe receiver possano essere passate come parametro ad areceive() ed asend() (non implementate).

<syntaxhighlight lang="python">
class receiver:
def __init__(self, peers):
"""
:param peers: list of processes this process communicates with.
"""
self._peers = tuple(peers)
self._printed = list()

def run(self):
while True:
process, message = areceive(ANY)

if process in self._peers:
self._reply_query(process, message)
else:
self._print(process, message)

def _print(self, sender, message):
h = hash(message.text)

if h not in self._printed and not self._printed_from_peers(message):
self._printed.append(h)
print(message.text)

def _reply_query(self, sender, h):
"""
Invoked when the current process receive a "query" from a peer process.
`h` contains the hash of a message which may or may have not been
sent from this process; if it was sent, the reply is `Yes`, otherwise `No`.
"""
reply = "Yes" if int(h) in self._printed else "No"
asend(sender, reply)

def _printed_from_peers(self, message):
"""
:return: `True` if this message has already been printed from any of the
peer processes, `False` otherwise.
"""
h = hash(message)

for p in self._peers:
asend(p, str(h))

for p in self._peers:
_, reply = areceive(p)

if reply.text == "Yes":
return True
else if reply.text != "No":
# If the response is neither "Yes" nor "No", then we have got a query
self._reply_query(p, reply)

return False
</syntaxhighlight>

=== Esercizio g.1 (da controllare) ===
Sulla base dei valori in entrata, è possibile costruire le matrici Allocation (q.tà di risorse allocate per processo e per tipo), Need (q.tà di risorse che ogni processo potrebbe ancora chiedere) e il vettore Available (num. di risorse correntemente disponibili).

{| class="wikitable" style="float: left"
! colspan=3 | Allocation
|-
! !! A !! B
|-
| p1 || 4 || 5
|-
| p2 || 3 || 3
|-
| p3 || 2 || 4
|}

{| class="wikitable" style="float: left; margin-left: 1em"
! colspan=3 | Need
|-
! !! A !! B
|-
| p1 || 6 || 8
|-
| p2 || 6 || 3
|-
| p3 || 6 || 8
|}

{| class="wikitable" style="float: left; margin-left: 1em"
! colspan=2 | Available
|-
! A !! B
|-
| x || y
|}

 

Nel caso delle risorse di tipo A, deve aversi x >= 6 in quanto un processo dovrà essere selezionato come primo nella permutazione dell'algoritmo del banchiere multivaluta, e tutti quelli correnti hanno lo stesso valore Need(i)(1); per ciò che riguarda le risorse di tipo B, possiamo ragionare per esaustione

* Se il primo processo della permutazione è p1, allora y >= 8 (con questo valore posso soddisfare la richiesta di p1 e in seguito tutte le altre)
* Se il primo processo della permutazione è p2, allora y >= 5: con questo valore è possibile soddisfare la richiesta di p2; una volta che esso avrà finito, restituirà 3 unità della risorsa B, che permetteranno di soddisfare sia le richieste di A sia quelle di C
* Se il primo processo della permutazione è p3, allora y >= 8 (ragionamento analogo come per p1)

Volendo scegliere il minimo, y >= 5, ed in conclusione (x, y) >= (6, 5).

''Svolgimento basato in parte sull'approccio di Operating System Concepts di Silberschatz. et al, 9th edition, cap. 7.''

=== Esercizio g.2 (da controllare) ===
# Può accadere che il sistema torni in uno stato di safety o che invece porti a deadlock. Diversamente uno stato di safety non può portare direttamente ad uno stato di deadlock, ma solo ad uno di non-safety.
# Selezionare uno o più tra i processi attivi e sospenderli, salvando il loro stato su memoria secondaria operando delle operazioni di swap-out, finché l'insieme dei frame nella memoria centrale non è in grado di soddisfare tutti i processi rimasti attivi.
# La scelta è determinata perlopiù dal fattore costo. Con un sistema RAID 1 è possibile ripristinare un disco guasto molto brevemente, in quanto le operazioni coinvolte prevedono una semplice ricopiatura dal disco di backup; con un sistema RAID 5 il ripristino del disco guasto deve coinvolgere tutti i dischi dell'intero array, e ciò può richiedere anche ore per dischi di grandi dimensioni. D'altra parte RAID 1 è più costoso (con n dischi, posso memorizzare tanta informazione quanto potrei con n / 2 dischi) rispetto a RAID 5 dove, tra gli n dischi, complessivamente soltanto uno è destinato alle informazioni di ridondanza.
# ''Completare.''

Prove scritte 2018

2023-05-12T14:48:40Z

LiberaL: /* Soluzione "schiacciasassi" */

= Esame 19/09/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.09.19.tot.pdf Testo dell'esame].

=== Esercizio c.2 (da controllare) ===

* Controllato dall'utente ? in data ?
* ...

Nello pseudocodice seguente, il termine this fa riferimento al processo corrente, mentre ANY ad uno qualunque.

<syntaxhighlight lang="c">
stack<message> messages;

void lifo_send(string m, process dest) {
do {
asend(m, dest);
} while (areceive(dest).text != "ACK");
}

message lifo_receive(process source) {
if (source != ANY) {
message m = areceive(source);

asend("ACK", source);

return m;
} else {
message m;

asend("END", this);
m = areceive(ANY);

while (m.text != "END" || m.sender != this) {
messages.push(m);
asend("ACK", m.sender);

m = areceive(ANY);
}

/* Bisogna tenere conto dei casi in cui lifo_receive() viene invocata quando nessun
* messaggio è stato ancora spedito da altri processi. In tal caso si attende il
* il primo e lo si restituisce.
*/
if (messages.empty()) {
m = areceive(ANY);
asend("ACK", m.sender);

return m;
} else {
return messages.pop();
}
}
}
</syntaxhighlight>

= Esame 17/07/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.07.17.tot.pdf 2018.07.17.tot.pdf]
== Esercizio c.1 ==
A Bruxelles c'è un locale chiamato Delirium Café. Alla vigilia del FOSDEM tutti gli anni gli sviluppatori europei di
software libero si ritrovano a bere birra (il locale è nel guinnes dei primati con più di duemila tipi di birra). Il prossimo appuntamento è
fissato per il 1 febbraio 2019 ore 20. Numerosi sono i tipi di birra alla spina. I baristi (tanti) prendono gli ordini (es. mezza pinta, 1 o 2
pinte) e riempiono i bicchieri. Quando un fusto e' vuoto avvertono i magazzinieri che prendono un nuovo fusto che contiene più di
cento pinte e lo sostituiscono, a questo punto il barista può completare il riempimento del bicchiere.
La vita di un barista del Delirium è:
while True:
(type, quantity) = get_order()
delirium.pour(type, quantity)
La vita di un Magazziniere è:
while True:
type = delirium.isempty()
capacity = change_keg(type)
delirium.loaded(type, capacity)

Attenzione: se il fusto (keg) è quasi vuoto il barista dovrà riempire parzialmente il bicchiere, occorrerà attivare il magazziniere che
cambierà il fusto e poi il barista riempirà il bicchiere fino alla quantità richiesta dal cliente. Mentre un barista sta attendendo il
cambiamento di un fusto altri baristi potrebbero ricevere ordini per lo stesso tipo di birra: gestire opportunamente questo caso.
Scrivere il monitor Delirium.

=== Proposta di soluzione 1 ===
* ERRORE: Secondo me c'è un leggero errore nella parte di load, nel caso in cui la nuova pinta non riesca a soddisfare completamente la richiesta ossia quando vale availableBeer[t] <= requests[t].head(), allora non lo risveglio nemmeno, invece dovrei risvegliare il pour, fargli versare quanto può, e richiedere una altra pinta, perché questo era un requisito del problema. [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 12:00, 15 January 2023 (CET)

<syntaxhighlight lang="c">
/* Monitor Delirum: */

// Condition: Ok2Load;
// Condition: Ok2Pour[]; // Un elemento per Type
int availableBeer[]; // Un elemento per Type
Queue requests[]; // Un elemento per Type
Queue pendingRequests;

Procedure entry: void Pour(Type t, Quantity c)
{
if (c > availableBeer[t]) // Richiesta maggiore della birra disponibile
{
c -= availableBeer[t];
availableBeer[t] = 0;
requests[t].Enqueue(c);
if (requests[t].Length == 1) // Risveglio un magazziniere solo se è la prima richiesta di questo tipo di birra
{
pendingRequests.Enqueue(t);
Ok2Load().Signal();
}
Ok2Pour[t].Wait();
requests[t].Dequeue(); // Quando ho ottenuto la birra che voglio, elimino la mia richiesta
}
availableBeer[t] -= c;
}

Procedure entry: Type isEmpty()
{
if (pendingRequests.Length == 0)
{
Ok2Load.Wait();
}
return pendingRequests.Dequeue();
}

Procedure entry: Loaded(Type t, Capacity c)
{
availableBeer[t] += c;
while (requests[t].Length > 0 && availableBeer[t] > requests[t].head())
{
Ok2Pour[t].Signal();
}

if (requests[t].Length > 0) // serve per evitare che a causa di un magazziniere lento si accodino cosi tante richieste che mentre si sta caricando si svuota subito il fusto
{
pendingRequests.Enqueue(t);
Ok2Load.Signal();
}
}
</syntaxhighlight>

=== Proposta di soluzione 2 ===
* Proposto da [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 13:41, 15 January 2023 (CET)
<syntaxhighlight lang="C">
extern int MAX_TYPE;
class Delirium {
int keg[MAX_TYPE]; // qnty fusto attuale
int orders[MAX_TYPE]; // qnty richiesta
bool worked[MAX_TYPE]; // 1 se magazziniere sta lavorando su questo.

condition type_wait[MAX_TYPE];
int num_wait[MAX_TYPE];

queue<int> empty_type;
condition is_empty;

entry pour(type, quantity) {
while (keg[type] < quantity) {
quantity -= keg[type];
keg[type] = 0;
if (!empty_type.find(type) && !worked[type]) {
empty_type.enqueue(type);
is_empty.signal();
}

num_wait[type]++;
type_wait[type].wait();
num_wait[type]--;
}
keg[type] -= quantity;
quantity = 0; // questo è inutile, ma concettualmente è corretto, l'ordine è completato.
}

entry loaded(type, capacity) {
keg[type] += capacity;
worked[type] = false;

for (int i = num_wait[type]; i > 0; i--) {
type_wait[type].signal();
}
}

// si suppone che un singolo tipo di fusto è lavorabile da un solo magazziniere alla volta.
// worked impedisce di avere nella coda un fusto su cuisi sta già lavorando.
entry isempty() {
if (empty_type.size() <= 0) {
is_emtpy.wait();
}
int type = emtpy_type.dequeue();
worked[type] = true;
return type;
}
}
</syntaxhighlight>

== Esercizio c.2 ==

=== Proposta di soluzione 1 ===
* Visto e corretto dall'utente [[User:Acsor|Acsor]] in data 23/08/2020
* Visto e corretto dall'utente ? in data ?
* Visto, ritenuto corretto [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 09:27, 15 January 2023 (CET)

<syntaxhighlight lang="c">
class LIFOBuffer {
stack<T> s;
semaphore mutex(1); // mutua esclusione
semaphore ok2consume(0);

void push (T value) {
mutex.P();
s.push(value);
// (1)
mutex.V()

ok2consume.V() // Curiosità: che succede se spostiamo quest'istruzione in (1)? Edit: funziona lo stesso, solo che aggiorni il valore del semaforo prima di uscire dalla mutex.
}

T pop () {
T value;

ok2consume.P();
mutex.P();
value = s.pop();
mutex.V();

return value;
}
}
</syntaxhighlight>

=== Proposta di soluzione 2 ===
Proposto da [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 09:27, 15 January 2023 (CET)

<syntaxhighlight lang="C">
class lifobuf {
semaphore mutex(1);
stack<int> values; // empty initialized
stack<semaphore> waiting;

push(int value) {
mutex.P();
values.push(value);
if (waiting.size() > 0) {
semaphore s = waiting.pop();
s.V();
return;
}

mutex.V();
}

pop() {
int ret_val;
mutex.P();
if (values.size() <= 0) {
semaphore s = new semaphore(0);
waiting.push(s);
mutex.V();
s.P();
free(s);
}

ret_val = values.pop();
mutex.V();

return ret_val;
}
}
</syntaxhighlight>

== Esercizio g.1 ==
Possiamo notare subito che il sistema ha due processori ed un dispositivo di I/O.
'''A''' e '''B''' partono insieme al tempo 0. 
'''C''' parte tra il tempo 0 ed il tempo 2 (non possiamo sapere di preciso quando perchè entrambe le CPU sono occupate). 
'''D''' parte tra il tempo 0 ed il tempo 3. 
A questo punto possiamo supporre che tutti e 4 i processi partano in sequenza ('''A''', '''B''', '''C''', '''D''') nello stesso momento, e ognuno prende la prima CPU libera che trova. 
'''A''' lavora per 3ms, poi scade il time slice. 
Nel frattempo '''B''' lavora per 2ms, poi richiede I/O per 4ms. 
La CPU su cui lavora '''B''' quindi si libera, e si manda in esecuzione il processo '''C'''. 
Scaduto il time slice per '''A''', si da il controllo ad un nuovo processo. '''B''' è occupato con I/O, '''C''' sta già lavorando, quindi è il turno di '''D'''. 
'''C''' lavora per 3ms, poi richiede I/O per 3ms, che però è occupato da '''B''', quindi si mette in coda per utilizzarlo. 
La CPU su cui lavorava '''C''' si libera ed il controllo torna ad '''A''', che doveva lavorare ancora per 2ms prima di chiedere il controllo di I/O, quindi lavora e si mette in coda dietro a '''C'''. 
Tornando a '''D''', questo lavora per 3ms prima che scada il time slice. Anche '''B''' ha finito il lavoro e ha bisogno di una CPU. 
In questo momento sia '''D''' che '''B''' sono nella coda dei processi in stato ready, ma dal diagramma possiamo notare che il controllo torna a '''D'''. 
La CPU ha scelto a caso un processo tra i due, perchè arrivati a questo punto possiamo supporre che lo scheduler sia Round-Robin. 
'''B''' prende possesso della prima CPU che si libera, ovvero quella occupata da '''A''', poi lavora per 2ms e termina il suo lavoro. 
Nel momento in cui '''B''' termina il lavoro, scade anche il time slice per '''D''', e '''C''' termina di usare I/O. 
Abbiamo due processi ('''C''' e '''D''') in coda ready. Ma abbiamo anche due CPU libere, perchè '''A''' è in coda per I/O e ci entra appena '''C''' finisce di usarlo. 
Lo scheduler sceglie di mandare '''C''' sul primo processore e '''D''' sul secondo. 
'''A''' nel frattempo, lavora per 4ms con I/O. 
'''C''' lavora per 3ms, poi termina il suo lavoro. 
'''D''' lavora per 3ms, poi scade il time slice. Ci sono due processori liberi, quindi '''D''' riparte subito in esecuzione. 
'''D''' doveva lavorare ancora per 1ms prima di aver bisogno di I/O, quindi finisce e si mette in coda. 
Ma nello stesso momento '''A''' termina di usare I/O, si prende un processore libero e lavora per i suoi ultimi 2ms. 
'''D''' lavora per 1ms con I/O, poi prende il secondo processore libero e lavora per 1ms prima di terminare il suo lavoro. 

Il time slice è di 3ms, lo scheduler è di tipo Round-Robin. 
Il dispositivo di I/O è FIFO. L'ordine con cui partono i processi è quello alfabetico.

<syntaxhighlight lang="c">
A(){
compute_a1(); // 5ms
io_a(); // 4ms
compute_a2(); // 2ms
}

B(){
compute_b(); // 2ms
io_b(); // 4ms
compute_b(); // 2ms
}

C(){
compute_c(); // 3ms
io_c(); // 3ms
compute_c(); // 3ms
}

D(){
compute_d1(); // 10ms
io_d(); // 1ms
compute_d2(); // 1ms
}
</syntaxhighlight>
Lo scheduler potrebbe anche essere a priorità: 
Priorità '''B''' < priorità '''D''' < priorità '''C''' 
Priorità '''A''' = ? 
'''B''' fatto partire prima di '''C''' e '''D'''.
 

== Esercizio g.2 (da controllare) ==
# In sistemi dove dispositivi di archiviazione o supporti hardware per la memoria virtuale (e dunque per la paginazione, spesso utilizzata per realizzare il supporto di memoria virtuale) non sono presenti (es. sistemi embedded). ''(In sistemi real-time la memoria virtuale è praticabile? Annotare.)''
# Perchè ad esempio sulle chiavette USB quasi mai abbiamo il problema di dover utilizzare file di dimensione maggiore ai 4GB. Non utilizza il journaling, che richiede molteplici scritture per ogni azione ed in dispositivi portatili può ridurre di molto la durata. Non supporta i permessi sui file, e questo è un vantaggio per le chiavette USB, pensate per trasferire dati tra PC diversi.
# Per fornire parallelismo e ridondanza. Non è necessario fare backup dei dati sul disco, nel senso di mantenere una copia identica di dati già memorizzati altrove, in quanto diversi sistemi di codici permettono il rilevamento e/o la correzione di errori.
# Se in un grafo di Holt multirisorsa esiste un ciclo tra più processi e risorse, ciò non significa che allo stesso tempo non siano coinvolti processi con archi esclusivamente entranti. Ogni processo appartenente a questa categoria non è in attesa di risorse, e può dunque procedere con i suoi calcoli; quando avrà terminato rilascerà le risorse precedentemente allocategli, eventualmente sbloccando uno dei processi coinvolti nel ciclo.

= Esame 21/06/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.06.21.tot.pdf 2018.06.21.tot.pdf]
=== Esercizio c.1 (sbagliato) ===
<syntaxhighlight lang="c">
/* Monitor tmon */

define MAX n;
define TERRAFERMA 1;
define ISOLA 2;

semaphore ok2unload;
semaphore ok2load;
semaphore ok2ship;
semaphore mutex(1); // la rampa è zona critica --> mutua esclusione

stack ferry;
int current_port = 0;

Procedure entry: al_porto(int location)
{
current_port = location; // traghetto arriva a destinazione
ok2unload.signal(); // da il via per far sbarcare le macchine
ok2ship.wait(); // si ferma
current_port = 0; // traghetto sta viaggiando tra i due porti
}

Procedure entry: imbarca(int location)
{
mutex.wait(); // prende possesso della rampa
ferry.push(1); // sale sul traghetto
mutex.signal(); // libera la rampa
}

Procedure entry: imbarcato(int location)
{
if(ferry.lenght() == MAX) // se il traghetto è pieno da il via per farlo salpare
{
ok2load.wait();
ok2ship.signal();
}
}

Procedure entry: sbarca(int location)
{
mutex.wait(); // prende possesso della rampa
ferry.pop(); // scende dal traghetto
mutex.signal(); // libera la rampa
}

Procedure entry: sbarcato(int location)
{
if(ferry.lenght() == 0) // se il traghetto è vuoto da il via per far imbarcare le macchine
{
ok2unload.wait();
ok2load.signal();
}
}

</syntaxhighlight>
 

=== Esercizio c.1 ===
<syntaxhighlight lang="c">
/* Monitor tmon */

#define MAX n
#define NONE 0
#define TERRAFERMA 1
#define ISOLA 2

condition ok2unload;
condition ok2load[2];
condition ok2ship;
condition empty;

int onboard = 0;
int onramp = 0;
int current_port = NONE;

Procedure entry: al_porto(int location)
{
//arrivando
current_port = location;
ok2unload.signal();
if (onboard > 0)
empty.wait()
ok2load[location].signal()
if (onboard < MAX)
ok2ship.wait()
//partendo
current_port = NONE;
}

Procedure entry: imbarca(int location)
{
if (current_port != location || onramp > 0 || onboard >= MAX)
ok2load[location].wait()
onramp = 1;
}

Procedure entry: imbarcato(int location)
{
onramp = 0; onboard++;
if (onboard < MAX)
ok2load[location].signal();
else
ok2ship.signal();
}

Procedure entry: sbarca(int location)
{
if (current_port != location || onramp > 0)
ok2unload.wait()
onramp = 1;
}

Procedure entry: sbarcato(int location)
{
onramp = 0; onboard--;
if (onboard == 0)
empty.signal();
else
ok2unload.signal();
}
</syntaxhighlight>
 

=== Esercizio c.2 (sbagliato) ===
<syntaxhighlight lang="c">

#define N n // limite operazioni
semaphore mutex(1); // sezione critica

class lim_semaphore()
{
int value;
semaphore plus;
semaphore minus;

P()
{
mutex.P();
if(value < N)
{
if (value >= 0)
{
plus.P();
}
else
{
minus.V();
}
value--;
}
mutex.V();
}

V()
{
mutex.P();
if(value > -N)
{
if (value <= 0)
{
minus.P();
}
else
{
plus.V();
}
value++;
}
mutex.V();
}
}
</syntaxhighlight>
 

=== Esercizio c.2 ===
==== Soluzione "furba e facile" ====
* Visto dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]) in data 18:53, 9 September 2020 (CEST). Ritengo sia: corretto (perché l'ho fatto pressappoco uguale). (Ritengo anche che possedere strumenti di analisi formale per verificare la correttezza di codice simile sarebbe di grande ausilio.)

<syntaxhighlight lang="java">
class bounded_semaphore {
semaphore plus;
semaphore minus;
int value; // serve per significato

bounded_semaphore (int initval, unsigned maxval) {
value = initval;
plus = new semaphore(maxval + initval);
minus = new semaphore(maxval - initval);
}

void P() {
plus.P();
value--;
minus.V();
}

void V() {
minus.P();
value++;
plus.V();
}
}
</syntaxhighlight>

==== Soluzione "schiacciasassi" ====
Controllato da [https://t.me/llibera LiberaL] in data 2023/05/12, perchè nel primo if della V() si fa value >= - maxval? non dovrebbe essere + maxval?

<syntaxhighlight lang="java">
class bounded_semaphore {
semaphore mutex;
queue<semaphore> okmin, okmax;
int value;
unsigned maxval;

bounded_semaphore (int initval, unsigned maxval) {
value = initval;
this.maxval = maxval;
}

void P() {
mutex.P();

if (value <= -maxval) {
s=semaphore(0);
okmin.enqueue(s);
mutex.V();
s.P();
} else if (okmax.length() > 0) {
s = okmax.dequeue()
s.V();
mutex.V();
} else {
value--;
mutex.V();
}
}

void V() {
mutex.P();

if (value >= -maxval) { //qui...
s=semaphore(0);
okmax.enqueue(s);
mutex.V();
s.P();
} else if (okmin.length() > 0) {
s = okmin.dequeue()
s.V();
mutex.V();
} else {
value++;
mutex.V();
}
}
}
</syntaxhighlight>

=== Esercizio g.1 ===
* Controllato dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]), 23:17, 9 September 2020 (CEST). Ritengo sia: corretto

<nowiki>
IC = 10,10,10 // Capitale iniziale
COH = 4,4,4 // Saldo in cassa

MAX ATT RES AVAIL
P1 | 6,6,6 | 1,1,1 | 5,5,5 | 4,4,4
P2 | 6,6,6 | 1,1,1 | 5,5,5 | 5,5,5
P3 | 9,9,9 | 4,4,4 | 5,5,5 | 6,6,6
</nowiki>

Minimizzato

<nowiki>
IC = 4,4,4
COH = 1,1,1

MAX ATT RES
P1 | 3,3,3 | 1,1,1 | 2,2,2
P2 | 3,3,3 | 1,1,1 | 2,2,2
P3 | 3,3,3 | 1,1,1 | 2,2,2
</nowiki>

=== Esercizio g.2 (da controllare) ===

* Visto e rimaneggiato in data 19:40, 10 September 2020 (CEST) dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]])

<hr>

# Il calcolo del working set serve a determinare il numero di processi che possono essere mantenuti attivi sulla base del limite della memoria principale, più precisamente del suo numero di frame. Può essere svolto ad ogni page fault, ossia quando un processo tra quelli attivi richiede una pagina non presente in memoria, o prima di avviare un nuovo processo.
# La lunghezza massima di un file che può essere memorizzato su un file system di tipo FAT viene calcolata moltiplicando il massimo numero di cluster (dimensione dell'unità di allocazione) identificabili per la loro dimensione. Il massimo numero di cluster identificabili dipende da quanti bit sono allocati per numerarli, e per questa distinzione esistono varie versioni di FAT (FAT12, FAT16, FAT32).
## FAT32 memorizza la dimensione dei file in un intero unsigned da 32bit, e non può quindi gestire un file di dimensione superiore ai 2^32 bit = ~4GB.
## FAT16, allocando 16bit per identificare i cluster, può contarne al massimo 2^16 (65536). Prendendo quindi, ad esempio, un file system FAT16 con cluster da 32KB, possiamo avere file grandi al massimo 32KB*65536 = ~2GB.
## FAT12 di conseguenza può numerare al massimo 2^12 (4096) cluster, ma dato che il numero dei settori del disco viene memorizzato in un intero signed a 16bit, la massima dimensione del disco è 2^15 = 32MB. Ovviamente, non si può memorizzare un file di grandezza superiore alla dimensione dell'unità di memorizzazione stessa, e quindi anche i file in FAT12 possono avere dimensione massima di 32MB.
# Entrambi condividono l'intento di infettare host con codice malevolo, ma differiscono fondamentalmente nella modalità: i virus infettano programmi già esistenti mediante un ''virus dropper'', mentre i worm diffondono copie di se stessi, solitamente attraverso la rete.
# In vari casi sulla base della natura del sistema. Innanzitutto, in sistemi batch ciò avviene se non sono stati inseriti più processi per un certo lasso di tempo. In sistemi general-purpose (es. per PC o dispositivi mobili) tale condizione è verificabile se tutti i processi sono in attesa su una coda che non è quella dello scheduler (ad. es. di un semaforo o di una periferica di I/O); casi concreti sono pertanto il deadlock (di tutti i processi del sistema) o attesa generale di I/O. Infine sempre in sistemi general-purpose tale condizione può manifestarsi, stavolta in condizioni patologiche, se ogni processo è assegnato ad una propria CPU/core, lasciando pertanto la coda d'attesa vuota.

= Esame 28/05/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.05.28.tot.pdf 2018.05.28.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
Stack<int> entriesStack;

int vid[MAX];
condition ok2esci[MAX]
int in = 0;
int out = -1;

Procedure-entry: entra(int id) {
if (in >= MAX)
ok2entra.wait()
vid[in++] = id;
if (in < MAX)
ok2entra.signal()
else
out = MAX - 1;
}

Procedure-entry: esci(int id) {
int i;
for (i = 0; i < in; i++)
if (vid[i] == id)
break; //cerco l'indice di id nel vettore vid

if (i != out)
ok2esci[i].wait();

if (out > 0) {
out--;
ok2esci[out].signal();
} else {
out--;
in = 0;
ok2entra.signal();
}
}
</syntaxhighlight>
 

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">
Monitor riempisvuota {
Int MAXPROCESSI;
Stack s;
condition ok2enter;
condition ok2exit;

p.e void entra(getPid()){
if( s.size() >= MAXPROCESSI)
ok2enter.wait();
s.insert(getPid());
if(s.size() > MAXPROCESSI)
ok2exit.signal()
}

p.e void esci(getPid()){
if(s.size() > MAXPROCESSI && s.top == getPid()) {
s.pop();
ok2entra.signal()
}
else
ok2exit.wait();
}
</syntaxhighlight>
 
=== Esercizio c.2 (ERRATO) ===

* Soluzione proposta è errata, non puoi riceve in modo greedy e printare subito il carattere [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 11:33, 18 January 2023 (CET)

<syntaxhighlight lang="c">
proc[x]: x='a',...,'z'
while True:
//c sarà il carattere stampato dal processo precedente
(c, string) = arecv(*)
if(string == wait){
//mi metto in attesa di ricevere l'ACK da proc[x]
m=arecv(x);
}
if (c == NONE){
//significa che sei il primo a ricevere quella stringa
print(x);
if (len(string) > 1){
//mando la wait a tutti, il primo che riceve qualcosa da stampare manda una wait a tutti
asend(wait,*);
int l = len(string);
int i = 1;
while(l != 0){
asend(proc[string[i]], (x, string[i...]));
//si mette in attesa di ricevere l'ACK dal processo dell'ultima lettera della parola
m=areceive(proc[string[i]]);
//rimando la wait al processo per ribloccarlo
asend(wait, proc[string[i]])
l--;
i++;
}
//dopo aver finito la stampa della stringa sblocco tutti i processi
asend(ACK, *);
}
}else{
print(x);
asend(ACK, x);
//ricomincia il ciclo while, si rimette in attesa e il 'gestore gli rimanda la wait'
}
</syntaxhighlight>
 

=== Esercizio c.2 ===
[[User:Flecart|Flecart friend]] ([[User talk:Flecart|talk]]) cedo la proprità intellettuale di questa soluzione a flecart

<syntaxhighlight lang="c">
process [x]: x='a'..'z'
if(x=='a'){
asend(<NULL,NULL>,'b');
asend(<NULL,NULL>,'b');
}
While True:
<c,string>=arecv(x-1+26%26);
if(string==NULL):
<c,string>=arecv(*);
if(string!=NULL):
<c,string>=arecv(x-1+26%26);

if(string!=NULL):
if(string[0]==x):
print(string[0]);
if(string.len()>1):
aasend(<NULL,string[1:]>,(x+1)%26);
else:
aasend(<NULL,NULL>,(x+1)%26);
aasend(<NULL,NULL>,(x+1)%26);
else:
aasend(<NULL,string>,(x+1)%26);
else:
aasend(<NULL,NULL>,(x+1)%26);
aasend(<NULL,NULL>,(x+1)%26);

</syntaxhighlight>

=== Proposta c2 ===
* Proposto [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 11:31, 18 January 2023 (CET)

<syntaxhighlight lang="C">
proc[a]:
bool occupied = false;
queue<string> s;

while True {
(c, string) = arecv(*);

if (c == NONE) {
if (occupied) {
s.enqueue(string);
} else {
if (string.len() < 1)
continue;

occupied = true;
asend(string[0], (MIDDLE, string));
}
} else if (c == END) {
if (s.size() > 0) {
string ss = s.dequeue();
asend(string[0], (MIDLLE, string));
} else {
occupied = false;
}
} else {
print(x);
if (len(string) > 1)
asend(proc[string[0]], (MIDDLE, string[1:]));
else:
asend(proc[a], (END, ""));
}
}

proc[x]: x = 'b', ... 'z';
while True {
(c, string) = arecv(*);
if (c == NONE) {
asend(proc['a'], (NONE, string));
} else { // potrà essere solo MIDDLE
print(x);
if (len(string) > 1)
asend(proc[string[0]], (MIDDLE, string[1:]));
else:
asend(proc[a], (END, ""));
}
}
</syntaxhighlight>

= Esame 12/02/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.02.12.tot.pdf 2018.02.12.tot.pdf]

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">

monitor bridge:

int ncar
bool boat_on_0
bool boat_on_1 // per semplicità, quando nel codice si trova boat_on_(direction) oppure isBoat(direction)(),
// si valuta il valore booleano di direction e lo si applica sotto forma di stringa al simbolo
// ad esso adiacente
bool is_raised
queue waiting_mean // i valori possibili sono: boat0, boat1 oppure car
condition ok2go

entry car_enter(direction):
if is_raised || ncar == MAXCAR:
waiting_mean.enqueue(car)
ok2go.wait()
is_raised = false
++ncar

entry car_exit(direction):
--ncar
if (waiting_mean.top().isBoat() && ncar == 0) || waiting_mean.top().isCar(): // isBoat ritorna true se l'oggetto su cui
waiting_mean.dequeue() // è invocata è boat0 oppure boat1
ok2go.signal()

entry boat_enter(direction):
if !is_raised || boat_on_(direction):
waiting_mean.enqueue(boat)
ok2go.wait()
if waiting_mean.top().isBoat(!direction)():
waiting_mean.dequeue()
ok2go.signal()
is_raised = true
boat_on_(direction) = true

entry boat_exit(direction):
boat_on_(direction) = false
if !boat_on_(!direction):
waiting_mean.dequeue()
ok2go.signal()

</syntaxhighlight>

 

=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor bridge {
int carsOnBridge = 0;
int shipping[2] = {0, 0}; //navi da entrambe le direzioni
int status = NONE; //UP DOWN NONE
int last2pass = 0; //ultimo che ha passato il ponte
int waitingC = 0; //coda delle macchine che aspettano
int waitingS[2] = {0,0}; //navi che stanno aspettando

condition ok2ship[2]
condition ok2drive

entry car_enter(int direction){
if(carsOnBridge >= MAX || status == UP || waitingS[0] + waitingS[1] > 0 ){
waitingC++;ok2drive.wait;waitingC--;}
status = DOWN;
carsOnBridge++
if (carsOnBridge < MAX)
ok2drive.signal(); //vanno tutte le MAX car che stanno aspettando
}
entry car_exit(int direction){
carsOnBridge--
if (waitingS[0] + waitingS[1] == 0)
ok2drive.signal();
if(carsOnBridge == 0){
ok2ship[0].signal(); ok2ship[1].signal();
}
if(carsOnBridge + waitingS[0] + waitingS[1] == 0)
status = NONE
}

entry ship_enter(int direction){
if (bridge = DOWN || shipping[direction] != 0 || waitingC > 0)
{
waitingS[i]++; ok2ship[i].wait(); waitingS[i]--;
}
isBridgeUp = false;
shipping[i] = 1;

entry ship_exit(int direction){
shipping[i] = 0;
if (waitingC == 0)
ok2ship[i].signal()
else if(shipping[1-i] == 0)
ok2drive.signal();
if(carsOnBridge + waitingS[0] + waitingS[1] == 0)
status = NONE
}
</syntaxhighlight>

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">
monitor bridge {

UP=0;
DOWN=1;
bridgeis = DOWN;

bool carAreExiting = false;

condition ok2drive;
condition ok2barca[2];

waitingCar = 0;
carOnBridge = 0;

boatWaiting[2] = {0,0};
boatIsPassing[2] = {false,false}

entry car_enter(direction) {

if (bridgeis == DOWN)
if(carOnBridge == MAXCAR)
waitingCar++;
ok2drive.wait();
waitingCar--;
else if (carAreExiting)
waitingCar++;
ok2drive.wait();
waitingCar--;
else
if (boatIsPassing[0] || boatIsPassing[1])
waitingCar++;
ok2drive.wait();
waitingCar--;
bridgeis = DOWN;

carOnBridge++;
carAreExiting = false;
if(carOnBridge < MAXCAR && !carAreExiting)
ok2drive.signal();

}

entry car_exit(direction) {

carOnBridge--;
carAreExiting = true;

if(carOnBridge == 0)
carAreExiting = false;
if(boatWaiting[0] > 0)
bridgeis = UP;
ok2barca[0].signal();
else if (boatWaiting[1] > 0)
bridgeis = UP;
ok2barca[1].signal();
else
ok2drive.signal();
}

entry boat_enter(direction) {

if (bridgeis == UP)
| if (boatIsPassing[direction] == true)
| | boatWaiting[direction]++;
| | ok2barca.wait();
| | boatWaiting[direction]--;
else
| if (carOnBridge > 0)
| | boatWaiting[direction]++;
| | ok2barca.wait();
| | boatWaiting[direction]--;
| | bridgeis = UP;

boatIsPassing[direction] = true;

if(boatIsPassing[1-direction] == false && boatWaiting[1-direction] > 0)
ok2barca[1-direction].signal();

}

entry boat_exit(direction) {

boatIsPassing[direction] = false;

if (boatIsPassing[1-direction] == false)
if (waitingCar > 0)
bridgeis = DOWN;
ok2drive.signal();
else
if (waitingCar == 0)
ok2barca[direction].signal();

}
</syntaxhighlight>

=== Esercizio c.1 (sbagliato) ===
<syntaxhighlight lang="c">
monitor bridge
condition ok2passCar;
condition ok2passBoat;
condition ok2up;
condition ok2down;
int carOnBridge[2] = 0; //2 sensi di marcia
int boatUnderBridge[2] = 0;
boolean bridge_down = false; //vuol dire che il ponte parte alzato, true ponte abbassato

procedure entry car_enter(direction){
if(bridge_down && carOnBridge[direction] < MAXCAR){
carOnBridge[direction]++;
ok2passCar.signal();
}else if (bridge_down && boatUnderBridge[0] == 0 && boatUnderBridge[1] == 0){
//se non ci sono navi in transito e arriva una macchina abbassa ponte
ok2down.signal();
ok2passCar.signal();
ok2passBoat.wait();
}else{
ok2passCar.wait();
}
}

procedure entry car_exit(direction){
carOnBridge[direction]--;
if(carOnBridge[0] == 0 && carOnBridge[1] == 0){
bridge_down = false;
ok2up.signal();
}else{
ok2up.wait();
}
}

procedure entry boat_enter(direction){
if(!bridge_down && boatUnderBridge[direction] < 1){
boatUnderBridge[direction]++;
ok2passBoat.signal();
}else if(!bridge_down && carOnBridge[0] == 0 && carOnBridge[1] == 0){
ok2up.signal();
ok2passBoat.signal();
ok2passCar.wait();
}else {
ok2passBoat.wait();
}
}

procedure entry boat_exit(direction){
boatUnderBridge[direction]--;
if(boatUnderBridge[0] == 0 && boatUnderBridge[1] == 0){
bridge_down = true;
ok2down.signal();
}else{
ok2down.wait();
}
}
</syntaxhighlight>

=== Esercizio c.1 2o (sbagliato) ===
<syntaxhighlight lang="c">
#define car 1
#define ship 2
#define fromDX 1
#define fromSX 0

monitor bridge {
int carsOnBridge = 0;
int shippingDX = 0; //nave che sta passando dal lato destro
int shippingSX = 0; //nave che sta passando dal lato sinistro
bool isBridgeUp = false;
int last2pass = 0; //ultimo che ha passato il ponte
int waitingS = 0; //navi che stanno aspettando
int waitingC = 0 ; //auto che stanno aspettando

condition ok2ship
condition ok2drive

entry car_enter(int direction){
//un auto si ferma se il numero di auto sul ponte è massimo
//e se l'ultima a passare è stata un auto mentre ci sono navi in attesa
if(carsOnBridge == MAX || isBridgeUp || (last2pass==car && waitingS > 0) ){
waitingC++;
ok2drive.wait;
}
carsOnBridge++;
waitingC--;
}

entry car_exit(int direction){
carsOnBridge--;
last2pass = car;
if(carsOnBridge == 0 && waitingS>0){
isBrigdeUp = true;
ok2ship.signal;
}
}

entry ship_enter(int direction){
//se la barca viene da destra
if(direction == fromDX){
//si ferma anche quando c'è una nave che sta già attraversando nella sua stessa direzione
if (isBridgeup == false || shippingDX || (last2pass==ship && waitingC > 0) ){
waitingS++;
ok2ship.wait;
}
if (waitingS > 0)
waitingS--;
shippingDX = 1;
}
//se la barca viene da sinistra
else if(direction == fromSX){
if (isBridgeup == false || shippingSX || ( (last2pass==ship && waitingC > 0))){
waitingS++;
ok2ship.wait;
}
if (waitingS > 0)
waitingS--;
shippingSX = 1;

}
}

entry ship_exit(int direction){
if(direction == fromDX)
shippingDX = 0;
else if (direction == fromSX)
shippingSX = 0;
last2pass = ship;
if(shippingDX == 0 && shippingSX == 0 && waitingC)
isBrigdeUp == false;
ok2drive.signal;
else if(shippingDX == 0 && shippingSX == 0 && waitingS > 0)
ok2ship.signal;
}
}
</syntaxhighlight>

=== Esercizio c.2 (sbagliato) ===

# (Ri)Controllato dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]) in data 26/08/2020

<syntaxhighlight lang="python">
list printed_msg; # questa è una variabile condivisa che ai fini dell'esercizio non si può utilizzare (message passing)

process server[i]:
while true:
<msg, pid> = arecv(*)

if printed_msg.length == 0 or <msg, pid> is not in printed_msg:
printed_msg.append(<msg,id>)
print(msg)
</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
Nello svolgimento seguente, receiver incapsula l'ambiente privato del processo; _peers rappresenta il vettore di processi "fratelli" ai quali può essere chiesto di stampare un messaggio, mentre _printed contiene l'hash di tutti i messaggi stampati dal processo locale. Si suppone che istanze della classe receiver possano essere passate come parametro ad areceive() ed asend() (non implementate).

<syntaxhighlight lang="python">
class receiver:
def __init__(self, peers):
"""
:param peers: list of processes this process communicates with.
"""
self._peers = tuple(peers)
self._printed = list()

def run(self):
while True:
process, message = areceive(ANY)

if process in self._peers:
self._reply_query(process, message)
else:
self._print(process, message)

def _print(self, sender, message):
h = hash(message.text)

if h not in self._printed and not self._printed_from_peers(message):
self._printed.append(h)
print(message.text)

def _reply_query(self, sender, h):
"""
Invoked when the current process receive a "query" from a peer process.
`h` contains the hash of a message which may or may have not been
sent from this process; if it was sent, the reply is `Yes`, otherwise `No`.
"""
reply = "Yes" if int(h) in self._printed else "No"
asend(sender, reply)

def _printed_from_peers(self, message):
"""
:return: `True` if this message has already been printed from any of the
peer processes, `False` otherwise.
"""
h = hash(message)

for p in self._peers:
asend(p, str(h))

for p in self._peers:
_, reply = areceive(p)

if reply.text == "Yes":
return True
else if reply.text != "No":
# If the response is neither "Yes" nor "No", then we have got a query
self._reply_query(p, reply)

return False
</syntaxhighlight>

=== Esercizio g.1 (da controllare) ===
Sulla base dei valori in entrata, è possibile costruire le matrici Allocation (q.tà di risorse allocate per processo e per tipo), Need (q.tà di risorse che ogni processo potrebbe ancora chiedere) e il vettore Available (num. di risorse correntemente disponibili).

{| class="wikitable" style="float: left"
! colspan=3 | Allocation
|-
! !! A !! B
|-
| p1 || 4 || 5
|-
| p2 || 3 || 3
|-
| p3 || 2 || 4
|}

{| class="wikitable" style="float: left; margin-left: 1em"
! colspan=3 | Need
|-
! !! A !! B
|-
| p1 || 6 || 8
|-
| p2 || 6 || 3
|-
| p3 || 6 || 8
|}

{| class="wikitable" style="float: left; margin-left: 1em"
! colspan=2 | Available
|-
! A !! B
|-
| x || y
|}

 

Nel caso delle risorse di tipo A, deve aversi x >= 6 in quanto un processo dovrà essere selezionato come primo nella permutazione dell'algoritmo del banchiere multivaluta, e tutti quelli correnti hanno lo stesso valore Need(i)(1); per ciò che riguarda le risorse di tipo B, possiamo ragionare per esaustione

* Se il primo processo della permutazione è p1, allora y >= 8 (con questo valore posso soddisfare la richiesta di p1 e in seguito tutte le altre)
* Se il primo processo della permutazione è p2, allora y >= 5: con questo valore è possibile soddisfare la richiesta di p2; una volta che esso avrà finito, restituirà 3 unità della risorsa B, che permetteranno di soddisfare sia le richieste di A sia quelle di C
* Se il primo processo della permutazione è p3, allora y >= 8 (ragionamento analogo come per p1)

Volendo scegliere il minimo, y >= 5, ed in conclusione (x, y) >= (6, 5).

''Svolgimento basato in parte sull'approccio di Operating System Concepts di Silberschatz. et al, 9th edition, cap. 7.''

=== Esercizio g.2 (da controllare) ===
# Può accadere che il sistema torni in uno stato di safety o che invece porti a deadlock. Diversamente uno stato di safety non può portare direttamente ad uno stato di deadlock, ma solo ad uno di non-safety.
# Selezionare uno o più tra i processi attivi e sospenderli, salvando il loro stato su memoria secondaria operando delle operazioni di swap-out, finché l'insieme dei frame nella memoria centrale non è in grado di soddisfare tutti i processi rimasti attivi.
# La scelta è determinata perlopiù dal fattore costo. Con un sistema RAID 1 è possibile ripristinare un disco guasto molto brevemente, in quanto le operazioni coinvolte prevedono una semplice ricopiatura dal disco di backup; con un sistema RAID 5 il ripristino del disco guasto deve coinvolgere tutti i dischi dell'intero array, e ciò può richiedere anche ore per dischi di grandi dimensioni. D'altra parte RAID 1 è più costoso (con n dischi, posso memorizzare tanta informazione quanto potrei con n / 2 dischi) rispetto a RAID 5 dove, tra gli n dischi, complessivamente soltanto uno è destinato alle informazioni di ridondanza.
# ''Completare.''

Prove scritte 2018

2023-05-12T14:48:18Z

LiberaL: /* Soluzione "schiacciasassi" */

= Esame 19/09/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.09.19.tot.pdf Testo dell'esame].

=== Esercizio c.2 (da controllare) ===

* Controllato dall'utente ? in data ?
* ...

Nello pseudocodice seguente, il termine this fa riferimento al processo corrente, mentre ANY ad uno qualunque.

<syntaxhighlight lang="c">
stack<message> messages;

void lifo_send(string m, process dest) {
do {
asend(m, dest);
} while (areceive(dest).text != "ACK");
}

message lifo_receive(process source) {
if (source != ANY) {
message m = areceive(source);

asend("ACK", source);

return m;
} else {
message m;

asend("END", this);
m = areceive(ANY);

while (m.text != "END" || m.sender != this) {
messages.push(m);
asend("ACK", m.sender);

m = areceive(ANY);
}

/* Bisogna tenere conto dei casi in cui lifo_receive() viene invocata quando nessun
* messaggio è stato ancora spedito da altri processi. In tal caso si attende il
* il primo e lo si restituisce.
*/
if (messages.empty()) {
m = areceive(ANY);
asend("ACK", m.sender);

return m;
} else {
return messages.pop();
}
}
}
</syntaxhighlight>

= Esame 17/07/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.07.17.tot.pdf 2018.07.17.tot.pdf]
== Esercizio c.1 ==
A Bruxelles c'è un locale chiamato Delirium Café. Alla vigilia del FOSDEM tutti gli anni gli sviluppatori europei di
software libero si ritrovano a bere birra (il locale è nel guinnes dei primati con più di duemila tipi di birra). Il prossimo appuntamento è
fissato per il 1 febbraio 2019 ore 20. Numerosi sono i tipi di birra alla spina. I baristi (tanti) prendono gli ordini (es. mezza pinta, 1 o 2
pinte) e riempiono i bicchieri. Quando un fusto e' vuoto avvertono i magazzinieri che prendono un nuovo fusto che contiene più di
cento pinte e lo sostituiscono, a questo punto il barista può completare il riempimento del bicchiere.
La vita di un barista del Delirium è:
while True:
(type, quantity) = get_order()
delirium.pour(type, quantity)
La vita di un Magazziniere è:
while True:
type = delirium.isempty()
capacity = change_keg(type)
delirium.loaded(type, capacity)

Attenzione: se il fusto (keg) è quasi vuoto il barista dovrà riempire parzialmente il bicchiere, occorrerà attivare il magazziniere che
cambierà il fusto e poi il barista riempirà il bicchiere fino alla quantità richiesta dal cliente. Mentre un barista sta attendendo il
cambiamento di un fusto altri baristi potrebbero ricevere ordini per lo stesso tipo di birra: gestire opportunamente questo caso.
Scrivere il monitor Delirium.

=== Proposta di soluzione 1 ===
* ERRORE: Secondo me c'è un leggero errore nella parte di load, nel caso in cui la nuova pinta non riesca a soddisfare completamente la richiesta ossia quando vale availableBeer[t] <= requests[t].head(), allora non lo risveglio nemmeno, invece dovrei risvegliare il pour, fargli versare quanto può, e richiedere una altra pinta, perché questo era un requisito del problema. [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 12:00, 15 January 2023 (CET)

<syntaxhighlight lang="c">
/* Monitor Delirum: */

// Condition: Ok2Load;
// Condition: Ok2Pour[]; // Un elemento per Type
int availableBeer[]; // Un elemento per Type
Queue requests[]; // Un elemento per Type
Queue pendingRequests;

Procedure entry: void Pour(Type t, Quantity c)
{
if (c > availableBeer[t]) // Richiesta maggiore della birra disponibile
{
c -= availableBeer[t];
availableBeer[t] = 0;
requests[t].Enqueue(c);
if (requests[t].Length == 1) // Risveglio un magazziniere solo se è la prima richiesta di questo tipo di birra
{
pendingRequests.Enqueue(t);
Ok2Load().Signal();
}
Ok2Pour[t].Wait();
requests[t].Dequeue(); // Quando ho ottenuto la birra che voglio, elimino la mia richiesta
}
availableBeer[t] -= c;
}

Procedure entry: Type isEmpty()
{
if (pendingRequests.Length == 0)
{
Ok2Load.Wait();
}
return pendingRequests.Dequeue();
}

Procedure entry: Loaded(Type t, Capacity c)
{
availableBeer[t] += c;
while (requests[t].Length > 0 && availableBeer[t] > requests[t].head())
{
Ok2Pour[t].Signal();
}

if (requests[t].Length > 0) // serve per evitare che a causa di un magazziniere lento si accodino cosi tante richieste che mentre si sta caricando si svuota subito il fusto
{
pendingRequests.Enqueue(t);
Ok2Load.Signal();
}
}
</syntaxhighlight>

=== Proposta di soluzione 2 ===
* Proposto da [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 13:41, 15 January 2023 (CET)
<syntaxhighlight lang="C">
extern int MAX_TYPE;
class Delirium {
int keg[MAX_TYPE]; // qnty fusto attuale
int orders[MAX_TYPE]; // qnty richiesta
bool worked[MAX_TYPE]; // 1 se magazziniere sta lavorando su questo.

condition type_wait[MAX_TYPE];
int num_wait[MAX_TYPE];

queue<int> empty_type;
condition is_empty;

entry pour(type, quantity) {
while (keg[type] < quantity) {
quantity -= keg[type];
keg[type] = 0;
if (!empty_type.find(type) && !worked[type]) {
empty_type.enqueue(type);
is_empty.signal();
}

num_wait[type]++;
type_wait[type].wait();
num_wait[type]--;
}
keg[type] -= quantity;
quantity = 0; // questo è inutile, ma concettualmente è corretto, l'ordine è completato.
}

entry loaded(type, capacity) {
keg[type] += capacity;
worked[type] = false;

for (int i = num_wait[type]; i > 0; i--) {
type_wait[type].signal();
}
}

// si suppone che un singolo tipo di fusto è lavorabile da un solo magazziniere alla volta.
// worked impedisce di avere nella coda un fusto su cuisi sta già lavorando.
entry isempty() {
if (empty_type.size() <= 0) {
is_emtpy.wait();
}
int type = emtpy_type.dequeue();
worked[type] = true;
return type;
}
}
</syntaxhighlight>

== Esercizio c.2 ==

=== Proposta di soluzione 1 ===
* Visto e corretto dall'utente [[User:Acsor|Acsor]] in data 23/08/2020
* Visto e corretto dall'utente ? in data ?
* Visto, ritenuto corretto [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 09:27, 15 January 2023 (CET)

<syntaxhighlight lang="c">
class LIFOBuffer {
stack<T> s;
semaphore mutex(1); // mutua esclusione
semaphore ok2consume(0);

void push (T value) {
mutex.P();
s.push(value);
// (1)
mutex.V()

ok2consume.V() // Curiosità: che succede se spostiamo quest'istruzione in (1)? Edit: funziona lo stesso, solo che aggiorni il valore del semaforo prima di uscire dalla mutex.
}

T pop () {
T value;

ok2consume.P();
mutex.P();
value = s.pop();
mutex.V();

return value;
}
}
</syntaxhighlight>

=== Proposta di soluzione 2 ===
Proposto da [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 09:27, 15 January 2023 (CET)

<syntaxhighlight lang="C">
class lifobuf {
semaphore mutex(1);
stack<int> values; // empty initialized
stack<semaphore> waiting;

push(int value) {
mutex.P();
values.push(value);
if (waiting.size() > 0) {
semaphore s = waiting.pop();
s.V();
return;
}

mutex.V();
}

pop() {
int ret_val;
mutex.P();
if (values.size() <= 0) {
semaphore s = new semaphore(0);
waiting.push(s);
mutex.V();
s.P();
free(s);
}

ret_val = values.pop();
mutex.V();

return ret_val;
}
}
</syntaxhighlight>

== Esercizio g.1 ==
Possiamo notare subito che il sistema ha due processori ed un dispositivo di I/O.
'''A''' e '''B''' partono insieme al tempo 0. 
'''C''' parte tra il tempo 0 ed il tempo 2 (non possiamo sapere di preciso quando perchè entrambe le CPU sono occupate). 
'''D''' parte tra il tempo 0 ed il tempo 3. 
A questo punto possiamo supporre che tutti e 4 i processi partano in sequenza ('''A''', '''B''', '''C''', '''D''') nello stesso momento, e ognuno prende la prima CPU libera che trova. 
'''A''' lavora per 3ms, poi scade il time slice. 
Nel frattempo '''B''' lavora per 2ms, poi richiede I/O per 4ms. 
La CPU su cui lavora '''B''' quindi si libera, e si manda in esecuzione il processo '''C'''. 
Scaduto il time slice per '''A''', si da il controllo ad un nuovo processo. '''B''' è occupato con I/O, '''C''' sta già lavorando, quindi è il turno di '''D'''. 
'''C''' lavora per 3ms, poi richiede I/O per 3ms, che però è occupato da '''B''', quindi si mette in coda per utilizzarlo. 
La CPU su cui lavorava '''C''' si libera ed il controllo torna ad '''A''', che doveva lavorare ancora per 2ms prima di chiedere il controllo di I/O, quindi lavora e si mette in coda dietro a '''C'''. 
Tornando a '''D''', questo lavora per 3ms prima che scada il time slice. Anche '''B''' ha finito il lavoro e ha bisogno di una CPU. 
In questo momento sia '''D''' che '''B''' sono nella coda dei processi in stato ready, ma dal diagramma possiamo notare che il controllo torna a '''D'''. 
La CPU ha scelto a caso un processo tra i due, perchè arrivati a questo punto possiamo supporre che lo scheduler sia Round-Robin. 
'''B''' prende possesso della prima CPU che si libera, ovvero quella occupata da '''A''', poi lavora per 2ms e termina il suo lavoro. 
Nel momento in cui '''B''' termina il lavoro, scade anche il time slice per '''D''', e '''C''' termina di usare I/O. 
Abbiamo due processi ('''C''' e '''D''') in coda ready. Ma abbiamo anche due CPU libere, perchè '''A''' è in coda per I/O e ci entra appena '''C''' finisce di usarlo. 
Lo scheduler sceglie di mandare '''C''' sul primo processore e '''D''' sul secondo. 
'''A''' nel frattempo, lavora per 4ms con I/O. 
'''C''' lavora per 3ms, poi termina il suo lavoro. 
'''D''' lavora per 3ms, poi scade il time slice. Ci sono due processori liberi, quindi '''D''' riparte subito in esecuzione. 
'''D''' doveva lavorare ancora per 1ms prima di aver bisogno di I/O, quindi finisce e si mette in coda. 
Ma nello stesso momento '''A''' termina di usare I/O, si prende un processore libero e lavora per i suoi ultimi 2ms. 
'''D''' lavora per 1ms con I/O, poi prende il secondo processore libero e lavora per 1ms prima di terminare il suo lavoro. 

Il time slice è di 3ms, lo scheduler è di tipo Round-Robin. 
Il dispositivo di I/O è FIFO. L'ordine con cui partono i processi è quello alfabetico.

<syntaxhighlight lang="c">
A(){
compute_a1(); // 5ms
io_a(); // 4ms
compute_a2(); // 2ms
}

B(){
compute_b(); // 2ms
io_b(); // 4ms
compute_b(); // 2ms
}

C(){
compute_c(); // 3ms
io_c(); // 3ms
compute_c(); // 3ms
}

D(){
compute_d1(); // 10ms
io_d(); // 1ms
compute_d2(); // 1ms
}
</syntaxhighlight>
Lo scheduler potrebbe anche essere a priorità: 
Priorità '''B''' < priorità '''D''' < priorità '''C''' 
Priorità '''A''' = ? 
'''B''' fatto partire prima di '''C''' e '''D'''.
 

== Esercizio g.2 (da controllare) ==
# In sistemi dove dispositivi di archiviazione o supporti hardware per la memoria virtuale (e dunque per la paginazione, spesso utilizzata per realizzare il supporto di memoria virtuale) non sono presenti (es. sistemi embedded). ''(In sistemi real-time la memoria virtuale è praticabile? Annotare.)''
# Perchè ad esempio sulle chiavette USB quasi mai abbiamo il problema di dover utilizzare file di dimensione maggiore ai 4GB. Non utilizza il journaling, che richiede molteplici scritture per ogni azione ed in dispositivi portatili può ridurre di molto la durata. Non supporta i permessi sui file, e questo è un vantaggio per le chiavette USB, pensate per trasferire dati tra PC diversi.
# Per fornire parallelismo e ridondanza. Non è necessario fare backup dei dati sul disco, nel senso di mantenere una copia identica di dati già memorizzati altrove, in quanto diversi sistemi di codici permettono il rilevamento e/o la correzione di errori.
# Se in un grafo di Holt multirisorsa esiste un ciclo tra più processi e risorse, ciò non significa che allo stesso tempo non siano coinvolti processi con archi esclusivamente entranti. Ogni processo appartenente a questa categoria non è in attesa di risorse, e può dunque procedere con i suoi calcoli; quando avrà terminato rilascerà le risorse precedentemente allocategli, eventualmente sbloccando uno dei processi coinvolti nel ciclo.

= Esame 21/06/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.06.21.tot.pdf 2018.06.21.tot.pdf]
=== Esercizio c.1 (sbagliato) ===
<syntaxhighlight lang="c">
/* Monitor tmon */

define MAX n;
define TERRAFERMA 1;
define ISOLA 2;

semaphore ok2unload;
semaphore ok2load;
semaphore ok2ship;
semaphore mutex(1); // la rampa è zona critica --> mutua esclusione

stack ferry;
int current_port = 0;

Procedure entry: al_porto(int location)
{
current_port = location; // traghetto arriva a destinazione
ok2unload.signal(); // da il via per far sbarcare le macchine
ok2ship.wait(); // si ferma
current_port = 0; // traghetto sta viaggiando tra i due porti
}

Procedure entry: imbarca(int location)
{
mutex.wait(); // prende possesso della rampa
ferry.push(1); // sale sul traghetto
mutex.signal(); // libera la rampa
}

Procedure entry: imbarcato(int location)
{
if(ferry.lenght() == MAX) // se il traghetto è pieno da il via per farlo salpare
{
ok2load.wait();
ok2ship.signal();
}
}

Procedure entry: sbarca(int location)
{
mutex.wait(); // prende possesso della rampa
ferry.pop(); // scende dal traghetto
mutex.signal(); // libera la rampa
}

Procedure entry: sbarcato(int location)
{
if(ferry.lenght() == 0) // se il traghetto è vuoto da il via per far imbarcare le macchine
{
ok2unload.wait();
ok2load.signal();
}
}

</syntaxhighlight>
 

=== Esercizio c.1 ===
<syntaxhighlight lang="c">
/* Monitor tmon */

#define MAX n
#define NONE 0
#define TERRAFERMA 1
#define ISOLA 2

condition ok2unload;
condition ok2load[2];
condition ok2ship;
condition empty;

int onboard = 0;
int onramp = 0;
int current_port = NONE;

Procedure entry: al_porto(int location)
{
//arrivando
current_port = location;
ok2unload.signal();
if (onboard > 0)
empty.wait()
ok2load[location].signal()
if (onboard < MAX)
ok2ship.wait()
//partendo
current_port = NONE;
}

Procedure entry: imbarca(int location)
{
if (current_port != location || onramp > 0 || onboard >= MAX)
ok2load[location].wait()
onramp = 1;
}

Procedure entry: imbarcato(int location)
{
onramp = 0; onboard++;
if (onboard < MAX)
ok2load[location].signal();
else
ok2ship.signal();
}

Procedure entry: sbarca(int location)
{
if (current_port != location || onramp > 0)
ok2unload.wait()
onramp = 1;
}

Procedure entry: sbarcato(int location)
{
onramp = 0; onboard--;
if (onboard == 0)
empty.signal();
else
ok2unload.signal();
}
</syntaxhighlight>
 

=== Esercizio c.2 (sbagliato) ===
<syntaxhighlight lang="c">

#define N n // limite operazioni
semaphore mutex(1); // sezione critica

class lim_semaphore()
{
int value;
semaphore plus;
semaphore minus;

P()
{
mutex.P();
if(value < N)
{
if (value >= 0)
{
plus.P();
}
else
{
minus.V();
}
value--;
}
mutex.V();
}

V()
{
mutex.P();
if(value > -N)
{
if (value <= 0)
{
minus.P();
}
else
{
plus.V();
}
value++;
}
mutex.V();
}
}
</syntaxhighlight>
 

=== Esercizio c.2 ===
==== Soluzione "furba e facile" ====
* Visto dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]) in data 18:53, 9 September 2020 (CEST). Ritengo sia: corretto (perché l'ho fatto pressappoco uguale). (Ritengo anche che possedere strumenti di analisi formale per verificare la correttezza di codice simile sarebbe di grande ausilio.)

<syntaxhighlight lang="java">
class bounded_semaphore {
semaphore plus;
semaphore minus;
int value; // serve per significato

bounded_semaphore (int initval, unsigned maxval) {
value = initval;
plus = new semaphore(maxval + initval);
minus = new semaphore(maxval - initval);
}

void P() {
plus.P();
value--;
minus.V();
}

void V() {
minus.P();
value++;
plus.V();
}
}
</syntaxhighlight>

==== Soluzione "schiacciasassi" ====
Controllato da [https://t.me/llibera User:LiberaL] in data 2023/05/12, perchè nel primo if della V() si fa value >= - maxval? non dovrebbe essere + maxval?

<syntaxhighlight lang="java">
class bounded_semaphore {
semaphore mutex;
queue<semaphore> okmin, okmax;
int value;
unsigned maxval;

bounded_semaphore (int initval, unsigned maxval) {
value = initval;
this.maxval = maxval;
}

void P() {
mutex.P();

if (value <= -maxval) {
s=semaphore(0);
okmin.enqueue(s);
mutex.V();
s.P();
} else if (okmax.length() > 0) {
s = okmax.dequeue()
s.V();
mutex.V();
} else {
value--;
mutex.V();
}
}

void V() {
mutex.P();

if (value >= -maxval) { //qui...
s=semaphore(0);
okmax.enqueue(s);
mutex.V();
s.P();
} else if (okmin.length() > 0) {
s = okmin.dequeue()
s.V();
mutex.V();
} else {
value++;
mutex.V();
}
}
}
</syntaxhighlight>

=== Esercizio g.1 ===
* Controllato dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]), 23:17, 9 September 2020 (CEST). Ritengo sia: corretto

<nowiki>
IC = 10,10,10 // Capitale iniziale
COH = 4,4,4 // Saldo in cassa

MAX ATT RES AVAIL
P1 | 6,6,6 | 1,1,1 | 5,5,5 | 4,4,4
P2 | 6,6,6 | 1,1,1 | 5,5,5 | 5,5,5
P3 | 9,9,9 | 4,4,4 | 5,5,5 | 6,6,6
</nowiki>

Minimizzato

<nowiki>
IC = 4,4,4
COH = 1,1,1

MAX ATT RES
P1 | 3,3,3 | 1,1,1 | 2,2,2
P2 | 3,3,3 | 1,1,1 | 2,2,2
P3 | 3,3,3 | 1,1,1 | 2,2,2
</nowiki>

=== Esercizio g.2 (da controllare) ===

* Visto e rimaneggiato in data 19:40, 10 September 2020 (CEST) dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]])

<hr>

# Il calcolo del working set serve a determinare il numero di processi che possono essere mantenuti attivi sulla base del limite della memoria principale, più precisamente del suo numero di frame. Può essere svolto ad ogni page fault, ossia quando un processo tra quelli attivi richiede una pagina non presente in memoria, o prima di avviare un nuovo processo.
# La lunghezza massima di un file che può essere memorizzato su un file system di tipo FAT viene calcolata moltiplicando il massimo numero di cluster (dimensione dell'unità di allocazione) identificabili per la loro dimensione. Il massimo numero di cluster identificabili dipende da quanti bit sono allocati per numerarli, e per questa distinzione esistono varie versioni di FAT (FAT12, FAT16, FAT32).
## FAT32 memorizza la dimensione dei file in un intero unsigned da 32bit, e non può quindi gestire un file di dimensione superiore ai 2^32 bit = ~4GB.
## FAT16, allocando 16bit per identificare i cluster, può contarne al massimo 2^16 (65536). Prendendo quindi, ad esempio, un file system FAT16 con cluster da 32KB, possiamo avere file grandi al massimo 32KB*65536 = ~2GB.
## FAT12 di conseguenza può numerare al massimo 2^12 (4096) cluster, ma dato che il numero dei settori del disco viene memorizzato in un intero signed a 16bit, la massima dimensione del disco è 2^15 = 32MB. Ovviamente, non si può memorizzare un file di grandezza superiore alla dimensione dell'unità di memorizzazione stessa, e quindi anche i file in FAT12 possono avere dimensione massima di 32MB.
# Entrambi condividono l'intento di infettare host con codice malevolo, ma differiscono fondamentalmente nella modalità: i virus infettano programmi già esistenti mediante un ''virus dropper'', mentre i worm diffondono copie di se stessi, solitamente attraverso la rete.
# In vari casi sulla base della natura del sistema. Innanzitutto, in sistemi batch ciò avviene se non sono stati inseriti più processi per un certo lasso di tempo. In sistemi general-purpose (es. per PC o dispositivi mobili) tale condizione è verificabile se tutti i processi sono in attesa su una coda che non è quella dello scheduler (ad. es. di un semaforo o di una periferica di I/O); casi concreti sono pertanto il deadlock (di tutti i processi del sistema) o attesa generale di I/O. Infine sempre in sistemi general-purpose tale condizione può manifestarsi, stavolta in condizioni patologiche, se ogni processo è assegnato ad una propria CPU/core, lasciando pertanto la coda d'attesa vuota.

= Esame 28/05/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.05.28.tot.pdf 2018.05.28.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
Stack<int> entriesStack;

int vid[MAX];
condition ok2esci[MAX]
int in = 0;
int out = -1;

Procedure-entry: entra(int id) {
if (in >= MAX)
ok2entra.wait()
vid[in++] = id;
if (in < MAX)
ok2entra.signal()
else
out = MAX - 1;
}

Procedure-entry: esci(int id) {
int i;
for (i = 0; i < in; i++)
if (vid[i] == id)
break; //cerco l'indice di id nel vettore vid

if (i != out)
ok2esci[i].wait();

if (out > 0) {
out--;
ok2esci[out].signal();
} else {
out--;
in = 0;
ok2entra.signal();
}
}
</syntaxhighlight>
 

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">
Monitor riempisvuota {
Int MAXPROCESSI;
Stack s;
condition ok2enter;
condition ok2exit;

p.e void entra(getPid()){
if( s.size() >= MAXPROCESSI)
ok2enter.wait();
s.insert(getPid());
if(s.size() > MAXPROCESSI)
ok2exit.signal()
}

p.e void esci(getPid()){
if(s.size() > MAXPROCESSI && s.top == getPid()) {
s.pop();
ok2entra.signal()
}
else
ok2exit.wait();
}
</syntaxhighlight>
 
=== Esercizio c.2 (ERRATO) ===

* Soluzione proposta è errata, non puoi riceve in modo greedy e printare subito il carattere [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 11:33, 18 January 2023 (CET)

<syntaxhighlight lang="c">
proc[x]: x='a',...,'z'
while True:
//c sarà il carattere stampato dal processo precedente
(c, string) = arecv(*)
if(string == wait){
//mi metto in attesa di ricevere l'ACK da proc[x]
m=arecv(x);
}
if (c == NONE){
//significa che sei il primo a ricevere quella stringa
print(x);
if (len(string) > 1){
//mando la wait a tutti, il primo che riceve qualcosa da stampare manda una wait a tutti
asend(wait,*);
int l = len(string);
int i = 1;
while(l != 0){
asend(proc[string[i]], (x, string[i...]));
//si mette in attesa di ricevere l'ACK dal processo dell'ultima lettera della parola
m=areceive(proc[string[i]]);
//rimando la wait al processo per ribloccarlo
asend(wait, proc[string[i]])
l--;
i++;
}
//dopo aver finito la stampa della stringa sblocco tutti i processi
asend(ACK, *);
}
}else{
print(x);
asend(ACK, x);
//ricomincia il ciclo while, si rimette in attesa e il 'gestore gli rimanda la wait'
}
</syntaxhighlight>
 

=== Esercizio c.2 ===
[[User:Flecart|Flecart friend]] ([[User talk:Flecart|talk]]) cedo la proprità intellettuale di questa soluzione a flecart

<syntaxhighlight lang="c">
process [x]: x='a'..'z'
if(x=='a'){
asend(<NULL,NULL>,'b');
asend(<NULL,NULL>,'b');
}
While True:
<c,string>=arecv(x-1+26%26);
if(string==NULL):
<c,string>=arecv(*);
if(string!=NULL):
<c,string>=arecv(x-1+26%26);

if(string!=NULL):
if(string[0]==x):
print(string[0]);
if(string.len()>1):
aasend(<NULL,string[1:]>,(x+1)%26);
else:
aasend(<NULL,NULL>,(x+1)%26);
aasend(<NULL,NULL>,(x+1)%26);
else:
aasend(<NULL,string>,(x+1)%26);
else:
aasend(<NULL,NULL>,(x+1)%26);
aasend(<NULL,NULL>,(x+1)%26);

</syntaxhighlight>

=== Proposta c2 ===
* Proposto [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 11:31, 18 January 2023 (CET)

<syntaxhighlight lang="C">
proc[a]:
bool occupied = false;
queue<string> s;

while True {
(c, string) = arecv(*);

if (c == NONE) {
if (occupied) {
s.enqueue(string);
} else {
if (string.len() < 1)
continue;

occupied = true;
asend(string[0], (MIDDLE, string));
}
} else if (c == END) {
if (s.size() > 0) {
string ss = s.dequeue();
asend(string[0], (MIDLLE, string));
} else {
occupied = false;
}
} else {
print(x);
if (len(string) > 1)
asend(proc[string[0]], (MIDDLE, string[1:]));
else:
asend(proc[a], (END, ""));
}
}

proc[x]: x = 'b', ... 'z';
while True {
(c, string) = arecv(*);
if (c == NONE) {
asend(proc['a'], (NONE, string));
} else { // potrà essere solo MIDDLE
print(x);
if (len(string) > 1)
asend(proc[string[0]], (MIDDLE, string[1:]));
else:
asend(proc[a], (END, ""));
}
}
</syntaxhighlight>

= Esame 12/02/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.02.12.tot.pdf 2018.02.12.tot.pdf]

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">

monitor bridge:

int ncar
bool boat_on_0
bool boat_on_1 // per semplicità, quando nel codice si trova boat_on_(direction) oppure isBoat(direction)(),
// si valuta il valore booleano di direction e lo si applica sotto forma di stringa al simbolo
// ad esso adiacente
bool is_raised
queue waiting_mean // i valori possibili sono: boat0, boat1 oppure car
condition ok2go

entry car_enter(direction):
if is_raised || ncar == MAXCAR:
waiting_mean.enqueue(car)
ok2go.wait()
is_raised = false
++ncar

entry car_exit(direction):
--ncar
if (waiting_mean.top().isBoat() && ncar == 0) || waiting_mean.top().isCar(): // isBoat ritorna true se l'oggetto su cui
waiting_mean.dequeue() // è invocata è boat0 oppure boat1
ok2go.signal()

entry boat_enter(direction):
if !is_raised || boat_on_(direction):
waiting_mean.enqueue(boat)
ok2go.wait()
if waiting_mean.top().isBoat(!direction)():
waiting_mean.dequeue()
ok2go.signal()
is_raised = true
boat_on_(direction) = true

entry boat_exit(direction):
boat_on_(direction) = false
if !boat_on_(!direction):
waiting_mean.dequeue()
ok2go.signal()

</syntaxhighlight>

 

=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor bridge {
int carsOnBridge = 0;
int shipping[2] = {0, 0}; //navi da entrambe le direzioni
int status = NONE; //UP DOWN NONE
int last2pass = 0; //ultimo che ha passato il ponte
int waitingC = 0; //coda delle macchine che aspettano
int waitingS[2] = {0,0}; //navi che stanno aspettando

condition ok2ship[2]
condition ok2drive

entry car_enter(int direction){
if(carsOnBridge >= MAX || status == UP || waitingS[0] + waitingS[1] > 0 ){
waitingC++;ok2drive.wait;waitingC--;}
status = DOWN;
carsOnBridge++
if (carsOnBridge < MAX)
ok2drive.signal(); //vanno tutte le MAX car che stanno aspettando
}
entry car_exit(int direction){
carsOnBridge--
if (waitingS[0] + waitingS[1] == 0)
ok2drive.signal();
if(carsOnBridge == 0){
ok2ship[0].signal(); ok2ship[1].signal();
}
if(carsOnBridge + waitingS[0] + waitingS[1] == 0)
status = NONE
}

entry ship_enter(int direction){
if (bridge = DOWN || shipping[direction] != 0 || waitingC > 0)
{
waitingS[i]++; ok2ship[i].wait(); waitingS[i]--;
}
isBridgeUp = false;
shipping[i] = 1;

entry ship_exit(int direction){
shipping[i] = 0;
if (waitingC == 0)
ok2ship[i].signal()
else if(shipping[1-i] == 0)
ok2drive.signal();
if(carsOnBridge + waitingS[0] + waitingS[1] == 0)
status = NONE
}
</syntaxhighlight>

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">
monitor bridge {

UP=0;
DOWN=1;
bridgeis = DOWN;

bool carAreExiting = false;

condition ok2drive;
condition ok2barca[2];

waitingCar = 0;
carOnBridge = 0;

boatWaiting[2] = {0,0};
boatIsPassing[2] = {false,false}

entry car_enter(direction) {

if (bridgeis == DOWN)
if(carOnBridge == MAXCAR)
waitingCar++;
ok2drive.wait();
waitingCar--;
else if (carAreExiting)
waitingCar++;
ok2drive.wait();
waitingCar--;
else
if (boatIsPassing[0] || boatIsPassing[1])
waitingCar++;
ok2drive.wait();
waitingCar--;
bridgeis = DOWN;

carOnBridge++;
carAreExiting = false;
if(carOnBridge < MAXCAR && !carAreExiting)
ok2drive.signal();

}

entry car_exit(direction) {

carOnBridge--;
carAreExiting = true;

if(carOnBridge == 0)
carAreExiting = false;
if(boatWaiting[0] > 0)
bridgeis = UP;
ok2barca[0].signal();
else if (boatWaiting[1] > 0)
bridgeis = UP;
ok2barca[1].signal();
else
ok2drive.signal();
}

entry boat_enter(direction) {

if (bridgeis == UP)
| if (boatIsPassing[direction] == true)
| | boatWaiting[direction]++;
| | ok2barca.wait();
| | boatWaiting[direction]--;
else
| if (carOnBridge > 0)
| | boatWaiting[direction]++;
| | ok2barca.wait();
| | boatWaiting[direction]--;
| | bridgeis = UP;

boatIsPassing[direction] = true;

if(boatIsPassing[1-direction] == false && boatWaiting[1-direction] > 0)
ok2barca[1-direction].signal();

}

entry boat_exit(direction) {

boatIsPassing[direction] = false;

if (boatIsPassing[1-direction] == false)
if (waitingCar > 0)
bridgeis = DOWN;
ok2drive.signal();
else
if (waitingCar == 0)
ok2barca[direction].signal();

}
</syntaxhighlight>

=== Esercizio c.1 (sbagliato) ===
<syntaxhighlight lang="c">
monitor bridge
condition ok2passCar;
condition ok2passBoat;
condition ok2up;
condition ok2down;
int carOnBridge[2] = 0; //2 sensi di marcia
int boatUnderBridge[2] = 0;
boolean bridge_down = false; //vuol dire che il ponte parte alzato, true ponte abbassato

procedure entry car_enter(direction){
if(bridge_down && carOnBridge[direction] < MAXCAR){
carOnBridge[direction]++;
ok2passCar.signal();
}else if (bridge_down && boatUnderBridge[0] == 0 && boatUnderBridge[1] == 0){
//se non ci sono navi in transito e arriva una macchina abbassa ponte
ok2down.signal();
ok2passCar.signal();
ok2passBoat.wait();
}else{
ok2passCar.wait();
}
}

procedure entry car_exit(direction){
carOnBridge[direction]--;
if(carOnBridge[0] == 0 && carOnBridge[1] == 0){
bridge_down = false;
ok2up.signal();
}else{
ok2up.wait();
}
}

procedure entry boat_enter(direction){
if(!bridge_down && boatUnderBridge[direction] < 1){
boatUnderBridge[direction]++;
ok2passBoat.signal();
}else if(!bridge_down && carOnBridge[0] == 0 && carOnBridge[1] == 0){
ok2up.signal();
ok2passBoat.signal();
ok2passCar.wait();
}else {
ok2passBoat.wait();
}
}

procedure entry boat_exit(direction){
boatUnderBridge[direction]--;
if(boatUnderBridge[0] == 0 && boatUnderBridge[1] == 0){
bridge_down = true;
ok2down.signal();
}else{
ok2down.wait();
}
}
</syntaxhighlight>

=== Esercizio c.1 2o (sbagliato) ===
<syntaxhighlight lang="c">
#define car 1
#define ship 2
#define fromDX 1
#define fromSX 0

monitor bridge {
int carsOnBridge = 0;
int shippingDX = 0; //nave che sta passando dal lato destro
int shippingSX = 0; //nave che sta passando dal lato sinistro
bool isBridgeUp = false;
int last2pass = 0; //ultimo che ha passato il ponte
int waitingS = 0; //navi che stanno aspettando
int waitingC = 0 ; //auto che stanno aspettando

condition ok2ship
condition ok2drive

entry car_enter(int direction){
//un auto si ferma se il numero di auto sul ponte è massimo
//e se l'ultima a passare è stata un auto mentre ci sono navi in attesa
if(carsOnBridge == MAX || isBridgeUp || (last2pass==car && waitingS > 0) ){
waitingC++;
ok2drive.wait;
}
carsOnBridge++;
waitingC--;
}

entry car_exit(int direction){
carsOnBridge--;
last2pass = car;
if(carsOnBridge == 0 && waitingS>0){
isBrigdeUp = true;
ok2ship.signal;
}
}

entry ship_enter(int direction){
//se la barca viene da destra
if(direction == fromDX){
//si ferma anche quando c'è una nave che sta già attraversando nella sua stessa direzione
if (isBridgeup == false || shippingDX || (last2pass==ship && waitingC > 0) ){
waitingS++;
ok2ship.wait;
}
if (waitingS > 0)
waitingS--;
shippingDX = 1;
}
//se la barca viene da sinistra
else if(direction == fromSX){
if (isBridgeup == false || shippingSX || ( (last2pass==ship && waitingC > 0))){
waitingS++;
ok2ship.wait;
}
if (waitingS > 0)
waitingS--;
shippingSX = 1;

}
}

entry ship_exit(int direction){
if(direction == fromDX)
shippingDX = 0;
else if (direction == fromSX)
shippingSX = 0;
last2pass = ship;
if(shippingDX == 0 && shippingSX == 0 && waitingC)
isBrigdeUp == false;
ok2drive.signal;
else if(shippingDX == 0 && shippingSX == 0 && waitingS > 0)
ok2ship.signal;
}
}
</syntaxhighlight>

=== Esercizio c.2 (sbagliato) ===

# (Ri)Controllato dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]) in data 26/08/2020

<syntaxhighlight lang="python">
list printed_msg; # questa è una variabile condivisa che ai fini dell'esercizio non si può utilizzare (message passing)

process server[i]:
while true:
<msg, pid> = arecv(*)

if printed_msg.length == 0 or <msg, pid> is not in printed_msg:
printed_msg.append(<msg,id>)
print(msg)
</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
Nello svolgimento seguente, receiver incapsula l'ambiente privato del processo; _peers rappresenta il vettore di processi "fratelli" ai quali può essere chiesto di stampare un messaggio, mentre _printed contiene l'hash di tutti i messaggi stampati dal processo locale. Si suppone che istanze della classe receiver possano essere passate come parametro ad areceive() ed asend() (non implementate).

<syntaxhighlight lang="python">
class receiver:
def __init__(self, peers):
"""
:param peers: list of processes this process communicates with.
"""
self._peers = tuple(peers)
self._printed = list()

def run(self):
while True:
process, message = areceive(ANY)

if process in self._peers:
self._reply_query(process, message)
else:
self._print(process, message)

def _print(self, sender, message):
h = hash(message.text)

if h not in self._printed and not self._printed_from_peers(message):
self._printed.append(h)
print(message.text)

def _reply_query(self, sender, h):
"""
Invoked when the current process receive a "query" from a peer process.
`h` contains the hash of a message which may or may have not been
sent from this process; if it was sent, the reply is `Yes`, otherwise `No`.
"""
reply = "Yes" if int(h) in self._printed else "No"
asend(sender, reply)

def _printed_from_peers(self, message):
"""
:return: `True` if this message has already been printed from any of the
peer processes, `False` otherwise.
"""
h = hash(message)

for p in self._peers:
asend(p, str(h))

for p in self._peers:
_, reply = areceive(p)

if reply.text == "Yes":
return True
else if reply.text != "No":
# If the response is neither "Yes" nor "No", then we have got a query
self._reply_query(p, reply)

return False
</syntaxhighlight>

=== Esercizio g.1 (da controllare) ===
Sulla base dei valori in entrata, è possibile costruire le matrici Allocation (q.tà di risorse allocate per processo e per tipo), Need (q.tà di risorse che ogni processo potrebbe ancora chiedere) e il vettore Available (num. di risorse correntemente disponibili).

{| class="wikitable" style="float: left"
! colspan=3 | Allocation
|-
! !! A !! B
|-
| p1 || 4 || 5
|-
| p2 || 3 || 3
|-
| p3 || 2 || 4
|}

{| class="wikitable" style="float: left; margin-left: 1em"
! colspan=3 | Need
|-
! !! A !! B
|-
| p1 || 6 || 8
|-
| p2 || 6 || 3
|-
| p3 || 6 || 8
|}

{| class="wikitable" style="float: left; margin-left: 1em"
! colspan=2 | Available
|-
! A !! B
|-
| x || y
|}

 

Nel caso delle risorse di tipo A, deve aversi x >= 6 in quanto un processo dovrà essere selezionato come primo nella permutazione dell'algoritmo del banchiere multivaluta, e tutti quelli correnti hanno lo stesso valore Need(i)(1); per ciò che riguarda le risorse di tipo B, possiamo ragionare per esaustione

* Se il primo processo della permutazione è p1, allora y >= 8 (con questo valore posso soddisfare la richiesta di p1 e in seguito tutte le altre)
* Se il primo processo della permutazione è p2, allora y >= 5: con questo valore è possibile soddisfare la richiesta di p2; una volta che esso avrà finito, restituirà 3 unità della risorsa B, che permetteranno di soddisfare sia le richieste di A sia quelle di C
* Se il primo processo della permutazione è p3, allora y >= 8 (ragionamento analogo come per p1)

Volendo scegliere il minimo, y >= 5, ed in conclusione (x, y) >= (6, 5).

''Svolgimento basato in parte sull'approccio di Operating System Concepts di Silberschatz. et al, 9th edition, cap. 7.''

=== Esercizio g.2 (da controllare) ===
# Può accadere che il sistema torni in uno stato di safety o che invece porti a deadlock. Diversamente uno stato di safety non può portare direttamente ad uno stato di deadlock, ma solo ad uno di non-safety.
# Selezionare uno o più tra i processi attivi e sospenderli, salvando il loro stato su memoria secondaria operando delle operazioni di swap-out, finché l'insieme dei frame nella memoria centrale non è in grado di soddisfare tutti i processi rimasti attivi.
# La scelta è determinata perlopiù dal fattore costo. Con un sistema RAID 1 è possibile ripristinare un disco guasto molto brevemente, in quanto le operazioni coinvolte prevedono una semplice ricopiatura dal disco di backup; con un sistema RAID 5 il ripristino del disco guasto deve coinvolgere tutti i dischi dell'intero array, e ciò può richiedere anche ore per dischi di grandi dimensioni. D'altra parte RAID 1 è più costoso (con n dischi, posso memorizzare tanta informazione quanto potrei con n / 2 dischi) rispetto a RAID 5 dove, tra gli n dischi, complessivamente soltanto uno è destinato alle informazioni di ridondanza.
# ''Completare.''

Prove scritte 2018

2023-05-12T14:45:21Z

LiberaL: /* Soluzione "schiacciasassi" */

= Esame 19/09/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.09.19.tot.pdf Testo dell'esame].

=== Esercizio c.2 (da controllare) ===

* Controllato dall'utente ? in data ?
* ...

Nello pseudocodice seguente, il termine this fa riferimento al processo corrente, mentre ANY ad uno qualunque.

<syntaxhighlight lang="c">
stack<message> messages;

void lifo_send(string m, process dest) {
do {
asend(m, dest);
} while (areceive(dest).text != "ACK");
}

message lifo_receive(process source) {
if (source != ANY) {
message m = areceive(source);

asend("ACK", source);

return m;
} else {
message m;

asend("END", this);
m = areceive(ANY);

while (m.text != "END" || m.sender != this) {
messages.push(m);
asend("ACK", m.sender);

m = areceive(ANY);
}

/* Bisogna tenere conto dei casi in cui lifo_receive() viene invocata quando nessun
* messaggio è stato ancora spedito da altri processi. In tal caso si attende il
* il primo e lo si restituisce.
*/
if (messages.empty()) {
m = areceive(ANY);
asend("ACK", m.sender);

return m;
} else {
return messages.pop();
}
}
}
</syntaxhighlight>

= Esame 17/07/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.07.17.tot.pdf 2018.07.17.tot.pdf]
== Esercizio c.1 ==
A Bruxelles c'è un locale chiamato Delirium Café. Alla vigilia del FOSDEM tutti gli anni gli sviluppatori europei di
software libero si ritrovano a bere birra (il locale è nel guinnes dei primati con più di duemila tipi di birra). Il prossimo appuntamento è
fissato per il 1 febbraio 2019 ore 20. Numerosi sono i tipi di birra alla spina. I baristi (tanti) prendono gli ordini (es. mezza pinta, 1 o 2
pinte) e riempiono i bicchieri. Quando un fusto e' vuoto avvertono i magazzinieri che prendono un nuovo fusto che contiene più di
cento pinte e lo sostituiscono, a questo punto il barista può completare il riempimento del bicchiere.
La vita di un barista del Delirium è:
while True:
(type, quantity) = get_order()
delirium.pour(type, quantity)
La vita di un Magazziniere è:
while True:
type = delirium.isempty()
capacity = change_keg(type)
delirium.loaded(type, capacity)

Attenzione: se il fusto (keg) è quasi vuoto il barista dovrà riempire parzialmente il bicchiere, occorrerà attivare il magazziniere che
cambierà il fusto e poi il barista riempirà il bicchiere fino alla quantità richiesta dal cliente. Mentre un barista sta attendendo il
cambiamento di un fusto altri baristi potrebbero ricevere ordini per lo stesso tipo di birra: gestire opportunamente questo caso.
Scrivere il monitor Delirium.

=== Proposta di soluzione 1 ===
* ERRORE: Secondo me c'è un leggero errore nella parte di load, nel caso in cui la nuova pinta non riesca a soddisfare completamente la richiesta ossia quando vale availableBeer[t] <= requests[t].head(), allora non lo risveglio nemmeno, invece dovrei risvegliare il pour, fargli versare quanto può, e richiedere una altra pinta, perché questo era un requisito del problema. [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 12:00, 15 January 2023 (CET)

<syntaxhighlight lang="c">
/* Monitor Delirum: */

// Condition: Ok2Load;
// Condition: Ok2Pour[]; // Un elemento per Type
int availableBeer[]; // Un elemento per Type
Queue requests[]; // Un elemento per Type
Queue pendingRequests;

Procedure entry: void Pour(Type t, Quantity c)
{
if (c > availableBeer[t]) // Richiesta maggiore della birra disponibile
{
c -= availableBeer[t];
availableBeer[t] = 0;
requests[t].Enqueue(c);
if (requests[t].Length == 1) // Risveglio un magazziniere solo se è la prima richiesta di questo tipo di birra
{
pendingRequests.Enqueue(t);
Ok2Load().Signal();
}
Ok2Pour[t].Wait();
requests[t].Dequeue(); // Quando ho ottenuto la birra che voglio, elimino la mia richiesta
}
availableBeer[t] -= c;
}

Procedure entry: Type isEmpty()
{
if (pendingRequests.Length == 0)
{
Ok2Load.Wait();
}
return pendingRequests.Dequeue();
}

Procedure entry: Loaded(Type t, Capacity c)
{
availableBeer[t] += c;
while (requests[t].Length > 0 && availableBeer[t] > requests[t].head())
{
Ok2Pour[t].Signal();
}

if (requests[t].Length > 0) // serve per evitare che a causa di un magazziniere lento si accodino cosi tante richieste che mentre si sta caricando si svuota subito il fusto
{
pendingRequests.Enqueue(t);
Ok2Load.Signal();
}
}
</syntaxhighlight>

=== Proposta di soluzione 2 ===
* Proposto da [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 13:41, 15 January 2023 (CET)
<syntaxhighlight lang="C">
extern int MAX_TYPE;
class Delirium {
int keg[MAX_TYPE]; // qnty fusto attuale
int orders[MAX_TYPE]; // qnty richiesta
bool worked[MAX_TYPE]; // 1 se magazziniere sta lavorando su questo.

condition type_wait[MAX_TYPE];
int num_wait[MAX_TYPE];

queue<int> empty_type;
condition is_empty;

entry pour(type, quantity) {
while (keg[type] < quantity) {
quantity -= keg[type];
keg[type] = 0;
if (!empty_type.find(type) && !worked[type]) {
empty_type.enqueue(type);
is_empty.signal();
}

num_wait[type]++;
type_wait[type].wait();
num_wait[type]--;
}
keg[type] -= quantity;
quantity = 0; // questo è inutile, ma concettualmente è corretto, l'ordine è completato.
}

entry loaded(type, capacity) {
keg[type] += capacity;
worked[type] = false;

for (int i = num_wait[type]; i > 0; i--) {
type_wait[type].signal();
}
}

// si suppone che un singolo tipo di fusto è lavorabile da un solo magazziniere alla volta.
// worked impedisce di avere nella coda un fusto su cuisi sta già lavorando.
entry isempty() {
if (empty_type.size() <= 0) {
is_emtpy.wait();
}
int type = emtpy_type.dequeue();
worked[type] = true;
return type;
}
}
</syntaxhighlight>

== Esercizio c.2 ==

=== Proposta di soluzione 1 ===
* Visto e corretto dall'utente [[User:Acsor|Acsor]] in data 23/08/2020
* Visto e corretto dall'utente ? in data ?
* Visto, ritenuto corretto [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 09:27, 15 January 2023 (CET)

<syntaxhighlight lang="c">
class LIFOBuffer {
stack<T> s;
semaphore mutex(1); // mutua esclusione
semaphore ok2consume(0);

void push (T value) {
mutex.P();
s.push(value);
// (1)
mutex.V()

ok2consume.V() // Curiosità: che succede se spostiamo quest'istruzione in (1)? Edit: funziona lo stesso, solo che aggiorni il valore del semaforo prima di uscire dalla mutex.
}

T pop () {
T value;

ok2consume.P();
mutex.P();
value = s.pop();
mutex.V();

return value;
}
}
</syntaxhighlight>

=== Proposta di soluzione 2 ===
Proposto da [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 09:27, 15 January 2023 (CET)

<syntaxhighlight lang="C">
class lifobuf {
semaphore mutex(1);
stack<int> values; // empty initialized
stack<semaphore> waiting;

push(int value) {
mutex.P();
values.push(value);
if (waiting.size() > 0) {
semaphore s = waiting.pop();
s.V();
return;
}

mutex.V();
}

pop() {
int ret_val;
mutex.P();
if (values.size() <= 0) {
semaphore s = new semaphore(0);
waiting.push(s);
mutex.V();
s.P();
free(s);
}

ret_val = values.pop();
mutex.V();

return ret_val;
}
}
</syntaxhighlight>

== Esercizio g.1 ==
Possiamo notare subito che il sistema ha due processori ed un dispositivo di I/O.
'''A''' e '''B''' partono insieme al tempo 0. 
'''C''' parte tra il tempo 0 ed il tempo 2 (non possiamo sapere di preciso quando perchè entrambe le CPU sono occupate). 
'''D''' parte tra il tempo 0 ed il tempo 3. 
A questo punto possiamo supporre che tutti e 4 i processi partano in sequenza ('''A''', '''B''', '''C''', '''D''') nello stesso momento, e ognuno prende la prima CPU libera che trova. 
'''A''' lavora per 3ms, poi scade il time slice. 
Nel frattempo '''B''' lavora per 2ms, poi richiede I/O per 4ms. 
La CPU su cui lavora '''B''' quindi si libera, e si manda in esecuzione il processo '''C'''. 
Scaduto il time slice per '''A''', si da il controllo ad un nuovo processo. '''B''' è occupato con I/O, '''C''' sta già lavorando, quindi è il turno di '''D'''. 
'''C''' lavora per 3ms, poi richiede I/O per 3ms, che però è occupato da '''B''', quindi si mette in coda per utilizzarlo. 
La CPU su cui lavorava '''C''' si libera ed il controllo torna ad '''A''', che doveva lavorare ancora per 2ms prima di chiedere il controllo di I/O, quindi lavora e si mette in coda dietro a '''C'''. 
Tornando a '''D''', questo lavora per 3ms prima che scada il time slice. Anche '''B''' ha finito il lavoro e ha bisogno di una CPU. 
In questo momento sia '''D''' che '''B''' sono nella coda dei processi in stato ready, ma dal diagramma possiamo notare che il controllo torna a '''D'''. 
La CPU ha scelto a caso un processo tra i due, perchè arrivati a questo punto possiamo supporre che lo scheduler sia Round-Robin. 
'''B''' prende possesso della prima CPU che si libera, ovvero quella occupata da '''A''', poi lavora per 2ms e termina il suo lavoro. 
Nel momento in cui '''B''' termina il lavoro, scade anche il time slice per '''D''', e '''C''' termina di usare I/O. 
Abbiamo due processi ('''C''' e '''D''') in coda ready. Ma abbiamo anche due CPU libere, perchè '''A''' è in coda per I/O e ci entra appena '''C''' finisce di usarlo. 
Lo scheduler sceglie di mandare '''C''' sul primo processore e '''D''' sul secondo. 
'''A''' nel frattempo, lavora per 4ms con I/O. 
'''C''' lavora per 3ms, poi termina il suo lavoro. 
'''D''' lavora per 3ms, poi scade il time slice. Ci sono due processori liberi, quindi '''D''' riparte subito in esecuzione. 
'''D''' doveva lavorare ancora per 1ms prima di aver bisogno di I/O, quindi finisce e si mette in coda. 
Ma nello stesso momento '''A''' termina di usare I/O, si prende un processore libero e lavora per i suoi ultimi 2ms. 
'''D''' lavora per 1ms con I/O, poi prende il secondo processore libero e lavora per 1ms prima di terminare il suo lavoro. 

Il time slice è di 3ms, lo scheduler è di tipo Round-Robin. 
Il dispositivo di I/O è FIFO. L'ordine con cui partono i processi è quello alfabetico.

<syntaxhighlight lang="c">
A(){
compute_a1(); // 5ms
io_a(); // 4ms
compute_a2(); // 2ms
}

B(){
compute_b(); // 2ms
io_b(); // 4ms
compute_b(); // 2ms
}

C(){
compute_c(); // 3ms
io_c(); // 3ms
compute_c(); // 3ms
}

D(){
compute_d1(); // 10ms
io_d(); // 1ms
compute_d2(); // 1ms
}
</syntaxhighlight>
Lo scheduler potrebbe anche essere a priorità: 
Priorità '''B''' < priorità '''D''' < priorità '''C''' 
Priorità '''A''' = ? 
'''B''' fatto partire prima di '''C''' e '''D'''.
 

== Esercizio g.2 (da controllare) ==
# In sistemi dove dispositivi di archiviazione o supporti hardware per la memoria virtuale (e dunque per la paginazione, spesso utilizzata per realizzare il supporto di memoria virtuale) non sono presenti (es. sistemi embedded). ''(In sistemi real-time la memoria virtuale è praticabile? Annotare.)''
# Perchè ad esempio sulle chiavette USB quasi mai abbiamo il problema di dover utilizzare file di dimensione maggiore ai 4GB. Non utilizza il journaling, che richiede molteplici scritture per ogni azione ed in dispositivi portatili può ridurre di molto la durata. Non supporta i permessi sui file, e questo è un vantaggio per le chiavette USB, pensate per trasferire dati tra PC diversi.
# Per fornire parallelismo e ridondanza. Non è necessario fare backup dei dati sul disco, nel senso di mantenere una copia identica di dati già memorizzati altrove, in quanto diversi sistemi di codici permettono il rilevamento e/o la correzione di errori.
# Se in un grafo di Holt multirisorsa esiste un ciclo tra più processi e risorse, ciò non significa che allo stesso tempo non siano coinvolti processi con archi esclusivamente entranti. Ogni processo appartenente a questa categoria non è in attesa di risorse, e può dunque procedere con i suoi calcoli; quando avrà terminato rilascerà le risorse precedentemente allocategli, eventualmente sbloccando uno dei processi coinvolti nel ciclo.

= Esame 21/06/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.06.21.tot.pdf 2018.06.21.tot.pdf]
=== Esercizio c.1 (sbagliato) ===
<syntaxhighlight lang="c">
/* Monitor tmon */

define MAX n;
define TERRAFERMA 1;
define ISOLA 2;

semaphore ok2unload;
semaphore ok2load;
semaphore ok2ship;
semaphore mutex(1); // la rampa è zona critica --> mutua esclusione

stack ferry;
int current_port = 0;

Procedure entry: al_porto(int location)
{
current_port = location; // traghetto arriva a destinazione
ok2unload.signal(); // da il via per far sbarcare le macchine
ok2ship.wait(); // si ferma
current_port = 0; // traghetto sta viaggiando tra i due porti
}

Procedure entry: imbarca(int location)
{
mutex.wait(); // prende possesso della rampa
ferry.push(1); // sale sul traghetto
mutex.signal(); // libera la rampa
}

Procedure entry: imbarcato(int location)
{
if(ferry.lenght() == MAX) // se il traghetto è pieno da il via per farlo salpare
{
ok2load.wait();
ok2ship.signal();
}
}

Procedure entry: sbarca(int location)
{
mutex.wait(); // prende possesso della rampa
ferry.pop(); // scende dal traghetto
mutex.signal(); // libera la rampa
}

Procedure entry: sbarcato(int location)
{
if(ferry.lenght() == 0) // se il traghetto è vuoto da il via per far imbarcare le macchine
{
ok2unload.wait();
ok2load.signal();
}
}

</syntaxhighlight>
 

=== Esercizio c.1 ===
<syntaxhighlight lang="c">
/* Monitor tmon */

#define MAX n
#define NONE 0
#define TERRAFERMA 1
#define ISOLA 2

condition ok2unload;
condition ok2load[2];
condition ok2ship;
condition empty;

int onboard = 0;
int onramp = 0;
int current_port = NONE;

Procedure entry: al_porto(int location)
{
//arrivando
current_port = location;
ok2unload.signal();
if (onboard > 0)
empty.wait()
ok2load[location].signal()
if (onboard < MAX)
ok2ship.wait()
//partendo
current_port = NONE;
}

Procedure entry: imbarca(int location)
{
if (current_port != location || onramp > 0 || onboard >= MAX)
ok2load[location].wait()
onramp = 1;
}

Procedure entry: imbarcato(int location)
{
onramp = 0; onboard++;
if (onboard < MAX)
ok2load[location].signal();
else
ok2ship.signal();
}

Procedure entry: sbarca(int location)
{
if (current_port != location || onramp > 0)
ok2unload.wait()
onramp = 1;
}

Procedure entry: sbarcato(int location)
{
onramp = 0; onboard--;
if (onboard == 0)
empty.signal();
else
ok2unload.signal();
}
</syntaxhighlight>
 

=== Esercizio c.2 (sbagliato) ===
<syntaxhighlight lang="c">

#define N n // limite operazioni
semaphore mutex(1); // sezione critica

class lim_semaphore()
{
int value;
semaphore plus;
semaphore minus;

P()
{
mutex.P();
if(value < N)
{
if (value >= 0)
{
plus.P();
}
else
{
minus.V();
}
value--;
}
mutex.V();
}

V()
{
mutex.P();
if(value > -N)
{
if (value <= 0)
{
minus.P();
}
else
{
plus.V();
}
value++;
}
mutex.V();
}
}
</syntaxhighlight>
 

=== Esercizio c.2 ===
==== Soluzione "furba e facile" ====
* Visto dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]) in data 18:53, 9 September 2020 (CEST). Ritengo sia: corretto (perché l'ho fatto pressappoco uguale). (Ritengo anche che possedere strumenti di analisi formale per verificare la correttezza di codice simile sarebbe di grande ausilio.)

<syntaxhighlight lang="java">
class bounded_semaphore {
semaphore plus;
semaphore minus;
int value; // serve per significato

bounded_semaphore (int initval, unsigned maxval) {
value = initval;
plus = new semaphore(maxval + initval);
minus = new semaphore(maxval - initval);
}

void P() {
plus.P();
value--;
minus.V();
}

void V() {
minus.P();
value++;
plus.V();
}
}
</syntaxhighlight>

==== Soluzione "schiacciasassi" ====
Controllato da [[https://t.me/llibera|LiberaL]] in data 2023/05/12, perchè nel primo if della V() si fa value >= - maxval? non dovrebbe essere + maxval?

<syntaxhighlight lang="java">
class bounded_semaphore {
semaphore mutex;
queue<semaphore> okmin, okmax;
int value;
unsigned maxval;

bounded_semaphore (int initval, unsigned maxval) {
value = initval;
this.maxval = maxval;
}

void P() {
mutex.P();

if (value <= -maxval) {
s=semaphore(0);
okmin.enqueue(s);
mutex.V();
s.P();
} else if (okmax.length() > 0) {
s = okmax.dequeue()
s.V();
mutex.V();
} else {
value--;
mutex.V();
}
}

void V() {
mutex.P();

if (value >= -maxval) { //qui...
s=semaphore(0);
okmax.enqueue(s);
mutex.V();
s.P();
} else if (okmin.length() > 0) {
s = okmin.dequeue()
s.V();
mutex.V();
} else {
value++;
mutex.V();
}
}
}
</syntaxhighlight>

=== Esercizio g.1 ===
* Controllato dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]), 23:17, 9 September 2020 (CEST). Ritengo sia: corretto

<nowiki>
IC = 10,10,10 // Capitale iniziale
COH = 4,4,4 // Saldo in cassa

MAX ATT RES AVAIL
P1 | 6,6,6 | 1,1,1 | 5,5,5 | 4,4,4
P2 | 6,6,6 | 1,1,1 | 5,5,5 | 5,5,5
P3 | 9,9,9 | 4,4,4 | 5,5,5 | 6,6,6
</nowiki>

Minimizzato

<nowiki>
IC = 4,4,4
COH = 1,1,1

MAX ATT RES
P1 | 3,3,3 | 1,1,1 | 2,2,2
P2 | 3,3,3 | 1,1,1 | 2,2,2
P3 | 3,3,3 | 1,1,1 | 2,2,2
</nowiki>

=== Esercizio g.2 (da controllare) ===

* Visto e rimaneggiato in data 19:40, 10 September 2020 (CEST) dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]])

<hr>

# Il calcolo del working set serve a determinare il numero di processi che possono essere mantenuti attivi sulla base del limite della memoria principale, più precisamente del suo numero di frame. Può essere svolto ad ogni page fault, ossia quando un processo tra quelli attivi richiede una pagina non presente in memoria, o prima di avviare un nuovo processo.
# La lunghezza massima di un file che può essere memorizzato su un file system di tipo FAT viene calcolata moltiplicando il massimo numero di cluster (dimensione dell'unità di allocazione) identificabili per la loro dimensione. Il massimo numero di cluster identificabili dipende da quanti bit sono allocati per numerarli, e per questa distinzione esistono varie versioni di FAT (FAT12, FAT16, FAT32).
## FAT32 memorizza la dimensione dei file in un intero unsigned da 32bit, e non può quindi gestire un file di dimensione superiore ai 2^32 bit = ~4GB.
## FAT16, allocando 16bit per identificare i cluster, può contarne al massimo 2^16 (65536). Prendendo quindi, ad esempio, un file system FAT16 con cluster da 32KB, possiamo avere file grandi al massimo 32KB*65536 = ~2GB.
## FAT12 di conseguenza può numerare al massimo 2^12 (4096) cluster, ma dato che il numero dei settori del disco viene memorizzato in un intero signed a 16bit, la massima dimensione del disco è 2^15 = 32MB. Ovviamente, non si può memorizzare un file di grandezza superiore alla dimensione dell'unità di memorizzazione stessa, e quindi anche i file in FAT12 possono avere dimensione massima di 32MB.
# Entrambi condividono l'intento di infettare host con codice malevolo, ma differiscono fondamentalmente nella modalità: i virus infettano programmi già esistenti mediante un ''virus dropper'', mentre i worm diffondono copie di se stessi, solitamente attraverso la rete.
# In vari casi sulla base della natura del sistema. Innanzitutto, in sistemi batch ciò avviene se non sono stati inseriti più processi per un certo lasso di tempo. In sistemi general-purpose (es. per PC o dispositivi mobili) tale condizione è verificabile se tutti i processi sono in attesa su una coda che non è quella dello scheduler (ad. es. di un semaforo o di una periferica di I/O); casi concreti sono pertanto il deadlock (di tutti i processi del sistema) o attesa generale di I/O. Infine sempre in sistemi general-purpose tale condizione può manifestarsi, stavolta in condizioni patologiche, se ogni processo è assegnato ad una propria CPU/core, lasciando pertanto la coda d'attesa vuota.

= Esame 28/05/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.05.28.tot.pdf 2018.05.28.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
Stack<int> entriesStack;

int vid[MAX];
condition ok2esci[MAX]
int in = 0;
int out = -1;

Procedure-entry: entra(int id) {
if (in >= MAX)
ok2entra.wait()
vid[in++] = id;
if (in < MAX)
ok2entra.signal()
else
out = MAX - 1;
}

Procedure-entry: esci(int id) {
int i;
for (i = 0; i < in; i++)
if (vid[i] == id)
break; //cerco l'indice di id nel vettore vid

if (i != out)
ok2esci[i].wait();

if (out > 0) {
out--;
ok2esci[out].signal();
} else {
out--;
in = 0;
ok2entra.signal();
}
}
</syntaxhighlight>
 

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">
Monitor riempisvuota {
Int MAXPROCESSI;
Stack s;
condition ok2enter;
condition ok2exit;

p.e void entra(getPid()){
if( s.size() >= MAXPROCESSI)
ok2enter.wait();
s.insert(getPid());
if(s.size() > MAXPROCESSI)
ok2exit.signal()
}

p.e void esci(getPid()){
if(s.size() > MAXPROCESSI && s.top == getPid()) {
s.pop();
ok2entra.signal()
}
else
ok2exit.wait();
}
</syntaxhighlight>
 
=== Esercizio c.2 (ERRATO) ===

* Soluzione proposta è errata, non puoi riceve in modo greedy e printare subito il carattere [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 11:33, 18 January 2023 (CET)

<syntaxhighlight lang="c">
proc[x]: x='a',...,'z'
while True:
//c sarà il carattere stampato dal processo precedente
(c, string) = arecv(*)
if(string == wait){
//mi metto in attesa di ricevere l'ACK da proc[x]
m=arecv(x);
}
if (c == NONE){
//significa che sei il primo a ricevere quella stringa
print(x);
if (len(string) > 1){
//mando la wait a tutti, il primo che riceve qualcosa da stampare manda una wait a tutti
asend(wait,*);
int l = len(string);
int i = 1;
while(l != 0){
asend(proc[string[i]], (x, string[i...]));
//si mette in attesa di ricevere l'ACK dal processo dell'ultima lettera della parola
m=areceive(proc[string[i]]);
//rimando la wait al processo per ribloccarlo
asend(wait, proc[string[i]])
l--;
i++;
}
//dopo aver finito la stampa della stringa sblocco tutti i processi
asend(ACK, *);
}
}else{
print(x);
asend(ACK, x);
//ricomincia il ciclo while, si rimette in attesa e il 'gestore gli rimanda la wait'
}
</syntaxhighlight>
 

=== Esercizio c.2 ===
[[User:Flecart|Flecart friend]] ([[User talk:Flecart|talk]]) cedo la proprità intellettuale di questa soluzione a flecart

<syntaxhighlight lang="c">
process [x]: x='a'..'z'
if(x=='a'){
asend(<NULL,NULL>,'b');
asend(<NULL,NULL>,'b');
}
While True:
<c,string>=arecv(x-1+26%26);
if(string==NULL):
<c,string>=arecv(*);
if(string!=NULL):
<c,string>=arecv(x-1+26%26);

if(string!=NULL):
if(string[0]==x):
print(string[0]);
if(string.len()>1):
aasend(<NULL,string[1:]>,(x+1)%26);
else:
aasend(<NULL,NULL>,(x+1)%26);
aasend(<NULL,NULL>,(x+1)%26);
else:
aasend(<NULL,string>,(x+1)%26);
else:
aasend(<NULL,NULL>,(x+1)%26);
aasend(<NULL,NULL>,(x+1)%26);

</syntaxhighlight>

=== Proposta c2 ===
* Proposto [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 11:31, 18 January 2023 (CET)

<syntaxhighlight lang="C">
proc[a]:
bool occupied = false;
queue<string> s;

while True {
(c, string) = arecv(*);

if (c == NONE) {
if (occupied) {
s.enqueue(string);
} else {
if (string.len() < 1)
continue;

occupied = true;
asend(string[0], (MIDDLE, string));
}
} else if (c == END) {
if (s.size() > 0) {
string ss = s.dequeue();
asend(string[0], (MIDLLE, string));
} else {
occupied = false;
}
} else {
print(x);
if (len(string) > 1)
asend(proc[string[0]], (MIDDLE, string[1:]));
else:
asend(proc[a], (END, ""));
}
}

proc[x]: x = 'b', ... 'z';
while True {
(c, string) = arecv(*);
if (c == NONE) {
asend(proc['a'], (NONE, string));
} else { // potrà essere solo MIDDLE
print(x);
if (len(string) > 1)
asend(proc[string[0]], (MIDDLE, string[1:]));
else:
asend(proc[a], (END, ""));
}
}
</syntaxhighlight>

= Esame 12/02/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.02.12.tot.pdf 2018.02.12.tot.pdf]

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">

monitor bridge:

int ncar
bool boat_on_0
bool boat_on_1 // per semplicità, quando nel codice si trova boat_on_(direction) oppure isBoat(direction)(),
// si valuta il valore booleano di direction e lo si applica sotto forma di stringa al simbolo
// ad esso adiacente
bool is_raised
queue waiting_mean // i valori possibili sono: boat0, boat1 oppure car
condition ok2go

entry car_enter(direction):
if is_raised || ncar == MAXCAR:
waiting_mean.enqueue(car)
ok2go.wait()
is_raised = false
++ncar

entry car_exit(direction):
--ncar
if (waiting_mean.top().isBoat() && ncar == 0) || waiting_mean.top().isCar(): // isBoat ritorna true se l'oggetto su cui
waiting_mean.dequeue() // è invocata è boat0 oppure boat1
ok2go.signal()

entry boat_enter(direction):
if !is_raised || boat_on_(direction):
waiting_mean.enqueue(boat)
ok2go.wait()
if waiting_mean.top().isBoat(!direction)():
waiting_mean.dequeue()
ok2go.signal()
is_raised = true
boat_on_(direction) = true

entry boat_exit(direction):
boat_on_(direction) = false
if !boat_on_(!direction):
waiting_mean.dequeue()
ok2go.signal()

</syntaxhighlight>

 

=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor bridge {
int carsOnBridge = 0;
int shipping[2] = {0, 0}; //navi da entrambe le direzioni
int status = NONE; //UP DOWN NONE
int last2pass = 0; //ultimo che ha passato il ponte
int waitingC = 0; //coda delle macchine che aspettano
int waitingS[2] = {0,0}; //navi che stanno aspettando

condition ok2ship[2]
condition ok2drive

entry car_enter(int direction){
if(carsOnBridge >= MAX || status == UP || waitingS[0] + waitingS[1] > 0 ){
waitingC++;ok2drive.wait;waitingC--;}
status = DOWN;
carsOnBridge++
if (carsOnBridge < MAX)
ok2drive.signal(); //vanno tutte le MAX car che stanno aspettando
}
entry car_exit(int direction){
carsOnBridge--
if (waitingS[0] + waitingS[1] == 0)
ok2drive.signal();
if(carsOnBridge == 0){
ok2ship[0].signal(); ok2ship[1].signal();
}
if(carsOnBridge + waitingS[0] + waitingS[1] == 0)
status = NONE
}

entry ship_enter(int direction){
if (bridge = DOWN || shipping[direction] != 0 || waitingC > 0)
{
waitingS[i]++; ok2ship[i].wait(); waitingS[i]--;
}
isBridgeUp = false;
shipping[i] = 1;

entry ship_exit(int direction){
shipping[i] = 0;
if (waitingC == 0)
ok2ship[i].signal()
else if(shipping[1-i] == 0)
ok2drive.signal();
if(carsOnBridge + waitingS[0] + waitingS[1] == 0)
status = NONE
}
</syntaxhighlight>

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">
monitor bridge {

UP=0;
DOWN=1;
bridgeis = DOWN;

bool carAreExiting = false;

condition ok2drive;
condition ok2barca[2];

waitingCar = 0;
carOnBridge = 0;

boatWaiting[2] = {0,0};
boatIsPassing[2] = {false,false}

entry car_enter(direction) {

if (bridgeis == DOWN)
if(carOnBridge == MAXCAR)
waitingCar++;
ok2drive.wait();
waitingCar--;
else if (carAreExiting)
waitingCar++;
ok2drive.wait();
waitingCar--;
else
if (boatIsPassing[0] || boatIsPassing[1])
waitingCar++;
ok2drive.wait();
waitingCar--;
bridgeis = DOWN;

carOnBridge++;
carAreExiting = false;
if(carOnBridge < MAXCAR && !carAreExiting)
ok2drive.signal();

}

entry car_exit(direction) {

carOnBridge--;
carAreExiting = true;

if(carOnBridge == 0)
carAreExiting = false;
if(boatWaiting[0] > 0)
bridgeis = UP;
ok2barca[0].signal();
else if (boatWaiting[1] > 0)
bridgeis = UP;
ok2barca[1].signal();
else
ok2drive.signal();
}

entry boat_enter(direction) {

if (bridgeis == UP)
| if (boatIsPassing[direction] == true)
| | boatWaiting[direction]++;
| | ok2barca.wait();
| | boatWaiting[direction]--;
else
| if (carOnBridge > 0)
| | boatWaiting[direction]++;
| | ok2barca.wait();
| | boatWaiting[direction]--;
| | bridgeis = UP;

boatIsPassing[direction] = true;

if(boatIsPassing[1-direction] == false && boatWaiting[1-direction] > 0)
ok2barca[1-direction].signal();

}

entry boat_exit(direction) {

boatIsPassing[direction] = false;

if (boatIsPassing[1-direction] == false)
if (waitingCar > 0)
bridgeis = DOWN;
ok2drive.signal();
else
if (waitingCar == 0)
ok2barca[direction].signal();

}
</syntaxhighlight>

=== Esercizio c.1 (sbagliato) ===
<syntaxhighlight lang="c">
monitor bridge
condition ok2passCar;
condition ok2passBoat;
condition ok2up;
condition ok2down;
int carOnBridge[2] = 0; //2 sensi di marcia
int boatUnderBridge[2] = 0;
boolean bridge_down = false; //vuol dire che il ponte parte alzato, true ponte abbassato

procedure entry car_enter(direction){
if(bridge_down && carOnBridge[direction] < MAXCAR){
carOnBridge[direction]++;
ok2passCar.signal();
}else if (bridge_down && boatUnderBridge[0] == 0 && boatUnderBridge[1] == 0){
//se non ci sono navi in transito e arriva una macchina abbassa ponte
ok2down.signal();
ok2passCar.signal();
ok2passBoat.wait();
}else{
ok2passCar.wait();
}
}

procedure entry car_exit(direction){
carOnBridge[direction]--;
if(carOnBridge[0] == 0 && carOnBridge[1] == 0){
bridge_down = false;
ok2up.signal();
}else{
ok2up.wait();
}
}

procedure entry boat_enter(direction){
if(!bridge_down && boatUnderBridge[direction] < 1){
boatUnderBridge[direction]++;
ok2passBoat.signal();
}else if(!bridge_down && carOnBridge[0] == 0 && carOnBridge[1] == 0){
ok2up.signal();
ok2passBoat.signal();
ok2passCar.wait();
}else {
ok2passBoat.wait();
}
}

procedure entry boat_exit(direction){
boatUnderBridge[direction]--;
if(boatUnderBridge[0] == 0 && boatUnderBridge[1] == 0){
bridge_down = true;
ok2down.signal();
}else{
ok2down.wait();
}
}
</syntaxhighlight>

=== Esercizio c.1 2o (sbagliato) ===
<syntaxhighlight lang="c">
#define car 1
#define ship 2
#define fromDX 1
#define fromSX 0

monitor bridge {
int carsOnBridge = 0;
int shippingDX = 0; //nave che sta passando dal lato destro
int shippingSX = 0; //nave che sta passando dal lato sinistro
bool isBridgeUp = false;
int last2pass = 0; //ultimo che ha passato il ponte
int waitingS = 0; //navi che stanno aspettando
int waitingC = 0 ; //auto che stanno aspettando

condition ok2ship
condition ok2drive

entry car_enter(int direction){
//un auto si ferma se il numero di auto sul ponte è massimo
//e se l'ultima a passare è stata un auto mentre ci sono navi in attesa
if(carsOnBridge == MAX || isBridgeUp || (last2pass==car && waitingS > 0) ){
waitingC++;
ok2drive.wait;
}
carsOnBridge++;
waitingC--;
}

entry car_exit(int direction){
carsOnBridge--;
last2pass = car;
if(carsOnBridge == 0 && waitingS>0){
isBrigdeUp = true;
ok2ship.signal;
}
}

entry ship_enter(int direction){
//se la barca viene da destra
if(direction == fromDX){
//si ferma anche quando c'è una nave che sta già attraversando nella sua stessa direzione
if (isBridgeup == false || shippingDX || (last2pass==ship && waitingC > 0) ){
waitingS++;
ok2ship.wait;
}
if (waitingS > 0)
waitingS--;
shippingDX = 1;
}
//se la barca viene da sinistra
else if(direction == fromSX){
if (isBridgeup == false || shippingSX || ( (last2pass==ship && waitingC > 0))){
waitingS++;
ok2ship.wait;
}
if (waitingS > 0)
waitingS--;
shippingSX = 1;

}
}

entry ship_exit(int direction){
if(direction == fromDX)
shippingDX = 0;
else if (direction == fromSX)
shippingSX = 0;
last2pass = ship;
if(shippingDX == 0 && shippingSX == 0 && waitingC)
isBrigdeUp == false;
ok2drive.signal;
else if(shippingDX == 0 && shippingSX == 0 && waitingS > 0)
ok2ship.signal;
}
}
</syntaxhighlight>

=== Esercizio c.2 (sbagliato) ===

# (Ri)Controllato dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]) in data 26/08/2020

<syntaxhighlight lang="python">
list printed_msg; # questa è una variabile condivisa che ai fini dell'esercizio non si può utilizzare (message passing)

process server[i]:
while true:
<msg, pid> = arecv(*)

if printed_msg.length == 0 or <msg, pid> is not in printed_msg:
printed_msg.append(<msg,id>)
print(msg)
</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
Nello svolgimento seguente, receiver incapsula l'ambiente privato del processo; _peers rappresenta il vettore di processi "fratelli" ai quali può essere chiesto di stampare un messaggio, mentre _printed contiene l'hash di tutti i messaggi stampati dal processo locale. Si suppone che istanze della classe receiver possano essere passate come parametro ad areceive() ed asend() (non implementate).

<syntaxhighlight lang="python">
class receiver:
def __init__(self, peers):
"""
:param peers: list of processes this process communicates with.
"""
self._peers = tuple(peers)
self._printed = list()

def run(self):
while True:
process, message = areceive(ANY)

if process in self._peers:
self._reply_query(process, message)
else:
self._print(process, message)

def _print(self, sender, message):
h = hash(message.text)

if h not in self._printed and not self._printed_from_peers(message):
self._printed.append(h)
print(message.text)

def _reply_query(self, sender, h):
"""
Invoked when the current process receive a "query" from a peer process.
`h` contains the hash of a message which may or may have not been
sent from this process; if it was sent, the reply is `Yes`, otherwise `No`.
"""
reply = "Yes" if int(h) in self._printed else "No"
asend(sender, reply)

def _printed_from_peers(self, message):
"""
:return: `True` if this message has already been printed from any of the
peer processes, `False` otherwise.
"""
h = hash(message)

for p in self._peers:
asend(p, str(h))

for p in self._peers:
_, reply = areceive(p)

if reply.text == "Yes":
return True
else if reply.text != "No":
# If the response is neither "Yes" nor "No", then we have got a query
self._reply_query(p, reply)

return False
</syntaxhighlight>

=== Esercizio g.1 (da controllare) ===
Sulla base dei valori in entrata, è possibile costruire le matrici Allocation (q.tà di risorse allocate per processo e per tipo), Need (q.tà di risorse che ogni processo potrebbe ancora chiedere) e il vettore Available (num. di risorse correntemente disponibili).

{| class="wikitable" style="float: left"
! colspan=3 | Allocation
|-
! !! A !! B
|-
| p1 || 4 || 5
|-
| p2 || 3 || 3
|-
| p3 || 2 || 4
|}

{| class="wikitable" style="float: left; margin-left: 1em"
! colspan=3 | Need
|-
! !! A !! B
|-
| p1 || 6 || 8
|-
| p2 || 6 || 3
|-
| p3 || 6 || 8
|}

{| class="wikitable" style="float: left; margin-left: 1em"
! colspan=2 | Available
|-
! A !! B
|-
| x || y
|}

 

Nel caso delle risorse di tipo A, deve aversi x >= 6 in quanto un processo dovrà essere selezionato come primo nella permutazione dell'algoritmo del banchiere multivaluta, e tutti quelli correnti hanno lo stesso valore Need(i)(1); per ciò che riguarda le risorse di tipo B, possiamo ragionare per esaustione

* Se il primo processo della permutazione è p1, allora y >= 8 (con questo valore posso soddisfare la richiesta di p1 e in seguito tutte le altre)
* Se il primo processo della permutazione è p2, allora y >= 5: con questo valore è possibile soddisfare la richiesta di p2; una volta che esso avrà finito, restituirà 3 unità della risorsa B, che permetteranno di soddisfare sia le richieste di A sia quelle di C
* Se il primo processo della permutazione è p3, allora y >= 8 (ragionamento analogo come per p1)

Volendo scegliere il minimo, y >= 5, ed in conclusione (x, y) >= (6, 5).

''Svolgimento basato in parte sull'approccio di Operating System Concepts di Silberschatz. et al, 9th edition, cap. 7.''

=== Esercizio g.2 (da controllare) ===
# Può accadere che il sistema torni in uno stato di safety o che invece porti a deadlock. Diversamente uno stato di safety non può portare direttamente ad uno stato di deadlock, ma solo ad uno di non-safety.
# Selezionare uno o più tra i processi attivi e sospenderli, salvando il loro stato su memoria secondaria operando delle operazioni di swap-out, finché l'insieme dei frame nella memoria centrale non è in grado di soddisfare tutti i processi rimasti attivi.
# La scelta è determinata perlopiù dal fattore costo. Con un sistema RAID 1 è possibile ripristinare un disco guasto molto brevemente, in quanto le operazioni coinvolte prevedono una semplice ricopiatura dal disco di backup; con un sistema RAID 5 il ripristino del disco guasto deve coinvolgere tutti i dischi dell'intero array, e ciò può richiedere anche ore per dischi di grandi dimensioni. D'altra parte RAID 1 è più costoso (con n dischi, posso memorizzare tanta informazione quanto potrei con n / 2 dischi) rispetto a RAID 5 dove, tra gli n dischi, complessivamente soltanto uno è destinato alle informazioni di ridondanza.
# ''Completare.''

Prove scritte 2018

2023-05-12T14:41:18Z

LiberaL: /* Soluzione "schiacciasassi" */

= Esame 19/09/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.09.19.tot.pdf Testo dell'esame].

=== Esercizio c.2 (da controllare) ===

* Controllato dall'utente ? in data ?
* ...

Nello pseudocodice seguente, il termine this fa riferimento al processo corrente, mentre ANY ad uno qualunque.

<syntaxhighlight lang="c">
stack<message> messages;

void lifo_send(string m, process dest) {
do {
asend(m, dest);
} while (areceive(dest).text != "ACK");
}

message lifo_receive(process source) {
if (source != ANY) {
message m = areceive(source);

asend("ACK", source);

return m;
} else {
message m;

asend("END", this);
m = areceive(ANY);

while (m.text != "END" || m.sender != this) {
messages.push(m);
asend("ACK", m.sender);

m = areceive(ANY);
}

/* Bisogna tenere conto dei casi in cui lifo_receive() viene invocata quando nessun
* messaggio è stato ancora spedito da altri processi. In tal caso si attende il
* il primo e lo si restituisce.
*/
if (messages.empty()) {
m = areceive(ANY);
asend("ACK", m.sender);

return m;
} else {
return messages.pop();
}
}
}
</syntaxhighlight>

= Esame 17/07/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.07.17.tot.pdf 2018.07.17.tot.pdf]
== Esercizio c.1 ==
A Bruxelles c'è un locale chiamato Delirium Café. Alla vigilia del FOSDEM tutti gli anni gli sviluppatori europei di
software libero si ritrovano a bere birra (il locale è nel guinnes dei primati con più di duemila tipi di birra). Il prossimo appuntamento è
fissato per il 1 febbraio 2019 ore 20. Numerosi sono i tipi di birra alla spina. I baristi (tanti) prendono gli ordini (es. mezza pinta, 1 o 2
pinte) e riempiono i bicchieri. Quando un fusto e' vuoto avvertono i magazzinieri che prendono un nuovo fusto che contiene più di
cento pinte e lo sostituiscono, a questo punto il barista può completare il riempimento del bicchiere.
La vita di un barista del Delirium è:
while True:
(type, quantity) = get_order()
delirium.pour(type, quantity)
La vita di un Magazziniere è:
while True:
type = delirium.isempty()
capacity = change_keg(type)
delirium.loaded(type, capacity)

Attenzione: se il fusto (keg) è quasi vuoto il barista dovrà riempire parzialmente il bicchiere, occorrerà attivare il magazziniere che
cambierà il fusto e poi il barista riempirà il bicchiere fino alla quantità richiesta dal cliente. Mentre un barista sta attendendo il
cambiamento di un fusto altri baristi potrebbero ricevere ordini per lo stesso tipo di birra: gestire opportunamente questo caso.
Scrivere il monitor Delirium.

=== Proposta di soluzione 1 ===
* ERRORE: Secondo me c'è un leggero errore nella parte di load, nel caso in cui la nuova pinta non riesca a soddisfare completamente la richiesta ossia quando vale availableBeer[t] <= requests[t].head(), allora non lo risveglio nemmeno, invece dovrei risvegliare il pour, fargli versare quanto può, e richiedere una altra pinta, perché questo era un requisito del problema. [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 12:00, 15 January 2023 (CET)

<syntaxhighlight lang="c">
/* Monitor Delirum: */

// Condition: Ok2Load;
// Condition: Ok2Pour[]; // Un elemento per Type
int availableBeer[]; // Un elemento per Type
Queue requests[]; // Un elemento per Type
Queue pendingRequests;

Procedure entry: void Pour(Type t, Quantity c)
{
if (c > availableBeer[t]) // Richiesta maggiore della birra disponibile
{
c -= availableBeer[t];
availableBeer[t] = 0;
requests[t].Enqueue(c);
if (requests[t].Length == 1) // Risveglio un magazziniere solo se è la prima richiesta di questo tipo di birra
{
pendingRequests.Enqueue(t);
Ok2Load().Signal();
}
Ok2Pour[t].Wait();
requests[t].Dequeue(); // Quando ho ottenuto la birra che voglio, elimino la mia richiesta
}
availableBeer[t] -= c;
}

Procedure entry: Type isEmpty()
{
if (pendingRequests.Length == 0)
{
Ok2Load.Wait();
}
return pendingRequests.Dequeue();
}

Procedure entry: Loaded(Type t, Capacity c)
{
availableBeer[t] += c;
while (requests[t].Length > 0 && availableBeer[t] > requests[t].head())
{
Ok2Pour[t].Signal();
}

if (requests[t].Length > 0) // serve per evitare che a causa di un magazziniere lento si accodino cosi tante richieste che mentre si sta caricando si svuota subito il fusto
{
pendingRequests.Enqueue(t);
Ok2Load.Signal();
}
}
</syntaxhighlight>

=== Proposta di soluzione 2 ===
* Proposto da [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 13:41, 15 January 2023 (CET)
<syntaxhighlight lang="C">
extern int MAX_TYPE;
class Delirium {
int keg[MAX_TYPE]; // qnty fusto attuale
int orders[MAX_TYPE]; // qnty richiesta
bool worked[MAX_TYPE]; // 1 se magazziniere sta lavorando su questo.

condition type_wait[MAX_TYPE];
int num_wait[MAX_TYPE];

queue<int> empty_type;
condition is_empty;

entry pour(type, quantity) {
while (keg[type] < quantity) {
quantity -= keg[type];
keg[type] = 0;
if (!empty_type.find(type) && !worked[type]) {
empty_type.enqueue(type);
is_empty.signal();
}

num_wait[type]++;
type_wait[type].wait();
num_wait[type]--;
}
keg[type] -= quantity;
quantity = 0; // questo è inutile, ma concettualmente è corretto, l'ordine è completato.
}

entry loaded(type, capacity) {
keg[type] += capacity;
worked[type] = false;

for (int i = num_wait[type]; i > 0; i--) {
type_wait[type].signal();
}
}

// si suppone che un singolo tipo di fusto è lavorabile da un solo magazziniere alla volta.
// worked impedisce di avere nella coda un fusto su cuisi sta già lavorando.
entry isempty() {
if (empty_type.size() <= 0) {
is_emtpy.wait();
}
int type = emtpy_type.dequeue();
worked[type] = true;
return type;
}
}
</syntaxhighlight>

== Esercizio c.2 ==

=== Proposta di soluzione 1 ===
* Visto e corretto dall'utente [[User:Acsor|Acsor]] in data 23/08/2020
* Visto e corretto dall'utente ? in data ?
* Visto, ritenuto corretto [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 09:27, 15 January 2023 (CET)

<syntaxhighlight lang="c">
class LIFOBuffer {
stack<T> s;
semaphore mutex(1); // mutua esclusione
semaphore ok2consume(0);

void push (T value) {
mutex.P();
s.push(value);
// (1)
mutex.V()

ok2consume.V() // Curiosità: che succede se spostiamo quest'istruzione in (1)? Edit: funziona lo stesso, solo che aggiorni il valore del semaforo prima di uscire dalla mutex.
}

T pop () {
T value;

ok2consume.P();
mutex.P();
value = s.pop();
mutex.V();

return value;
}
}
</syntaxhighlight>

=== Proposta di soluzione 2 ===
Proposto da [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 09:27, 15 January 2023 (CET)

<syntaxhighlight lang="C">
class lifobuf {
semaphore mutex(1);
stack<int> values; // empty initialized
stack<semaphore> waiting;

push(int value) {
mutex.P();
values.push(value);
if (waiting.size() > 0) {
semaphore s = waiting.pop();
s.V();
return;
}

mutex.V();
}

pop() {
int ret_val;
mutex.P();
if (values.size() <= 0) {
semaphore s = new semaphore(0);
waiting.push(s);
mutex.V();
s.P();
free(s);
}

ret_val = values.pop();
mutex.V();

return ret_val;
}
}
</syntaxhighlight>

== Esercizio g.1 ==
Possiamo notare subito che il sistema ha due processori ed un dispositivo di I/O.
'''A''' e '''B''' partono insieme al tempo 0. 
'''C''' parte tra il tempo 0 ed il tempo 2 (non possiamo sapere di preciso quando perchè entrambe le CPU sono occupate). 
'''D''' parte tra il tempo 0 ed il tempo 3. 
A questo punto possiamo supporre che tutti e 4 i processi partano in sequenza ('''A''', '''B''', '''C''', '''D''') nello stesso momento, e ognuno prende la prima CPU libera che trova. 
'''A''' lavora per 3ms, poi scade il time slice. 
Nel frattempo '''B''' lavora per 2ms, poi richiede I/O per 4ms. 
La CPU su cui lavora '''B''' quindi si libera, e si manda in esecuzione il processo '''C'''. 
Scaduto il time slice per '''A''', si da il controllo ad un nuovo processo. '''B''' è occupato con I/O, '''C''' sta già lavorando, quindi è il turno di '''D'''. 
'''C''' lavora per 3ms, poi richiede I/O per 3ms, che però è occupato da '''B''', quindi si mette in coda per utilizzarlo. 
La CPU su cui lavorava '''C''' si libera ed il controllo torna ad '''A''', che doveva lavorare ancora per 2ms prima di chiedere il controllo di I/O, quindi lavora e si mette in coda dietro a '''C'''. 
Tornando a '''D''', questo lavora per 3ms prima che scada il time slice. Anche '''B''' ha finito il lavoro e ha bisogno di una CPU. 
In questo momento sia '''D''' che '''B''' sono nella coda dei processi in stato ready, ma dal diagramma possiamo notare che il controllo torna a '''D'''. 
La CPU ha scelto a caso un processo tra i due, perchè arrivati a questo punto possiamo supporre che lo scheduler sia Round-Robin. 
'''B''' prende possesso della prima CPU che si libera, ovvero quella occupata da '''A''', poi lavora per 2ms e termina il suo lavoro. 
Nel momento in cui '''B''' termina il lavoro, scade anche il time slice per '''D''', e '''C''' termina di usare I/O. 
Abbiamo due processi ('''C''' e '''D''') in coda ready. Ma abbiamo anche due CPU libere, perchè '''A''' è in coda per I/O e ci entra appena '''C''' finisce di usarlo. 
Lo scheduler sceglie di mandare '''C''' sul primo processore e '''D''' sul secondo. 
'''A''' nel frattempo, lavora per 4ms con I/O. 
'''C''' lavora per 3ms, poi termina il suo lavoro. 
'''D''' lavora per 3ms, poi scade il time slice. Ci sono due processori liberi, quindi '''D''' riparte subito in esecuzione. 
'''D''' doveva lavorare ancora per 1ms prima di aver bisogno di I/O, quindi finisce e si mette in coda. 
Ma nello stesso momento '''A''' termina di usare I/O, si prende un processore libero e lavora per i suoi ultimi 2ms. 
'''D''' lavora per 1ms con I/O, poi prende il secondo processore libero e lavora per 1ms prima di terminare il suo lavoro. 

Il time slice è di 3ms, lo scheduler è di tipo Round-Robin. 
Il dispositivo di I/O è FIFO. L'ordine con cui partono i processi è quello alfabetico.

<syntaxhighlight lang="c">
A(){
compute_a1(); // 5ms
io_a(); // 4ms
compute_a2(); // 2ms
}

B(){
compute_b(); // 2ms
io_b(); // 4ms
compute_b(); // 2ms
}

C(){
compute_c(); // 3ms
io_c(); // 3ms
compute_c(); // 3ms
}

D(){
compute_d1(); // 10ms
io_d(); // 1ms
compute_d2(); // 1ms
}
</syntaxhighlight>
Lo scheduler potrebbe anche essere a priorità: 
Priorità '''B''' < priorità '''D''' < priorità '''C''' 
Priorità '''A''' = ? 
'''B''' fatto partire prima di '''C''' e '''D'''.
 

== Esercizio g.2 (da controllare) ==
# In sistemi dove dispositivi di archiviazione o supporti hardware per la memoria virtuale (e dunque per la paginazione, spesso utilizzata per realizzare il supporto di memoria virtuale) non sono presenti (es. sistemi embedded). ''(In sistemi real-time la memoria virtuale è praticabile? Annotare.)''
# Perchè ad esempio sulle chiavette USB quasi mai abbiamo il problema di dover utilizzare file di dimensione maggiore ai 4GB. Non utilizza il journaling, che richiede molteplici scritture per ogni azione ed in dispositivi portatili può ridurre di molto la durata. Non supporta i permessi sui file, e questo è un vantaggio per le chiavette USB, pensate per trasferire dati tra PC diversi.
# Per fornire parallelismo e ridondanza. Non è necessario fare backup dei dati sul disco, nel senso di mantenere una copia identica di dati già memorizzati altrove, in quanto diversi sistemi di codici permettono il rilevamento e/o la correzione di errori.
# Se in un grafo di Holt multirisorsa esiste un ciclo tra più processi e risorse, ciò non significa che allo stesso tempo non siano coinvolti processi con archi esclusivamente entranti. Ogni processo appartenente a questa categoria non è in attesa di risorse, e può dunque procedere con i suoi calcoli; quando avrà terminato rilascerà le risorse precedentemente allocategli, eventualmente sbloccando uno dei processi coinvolti nel ciclo.

= Esame 21/06/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.06.21.tot.pdf 2018.06.21.tot.pdf]
=== Esercizio c.1 (sbagliato) ===
<syntaxhighlight lang="c">
/* Monitor tmon */

define MAX n;
define TERRAFERMA 1;
define ISOLA 2;

semaphore ok2unload;
semaphore ok2load;
semaphore ok2ship;
semaphore mutex(1); // la rampa è zona critica --> mutua esclusione

stack ferry;
int current_port = 0;

Procedure entry: al_porto(int location)
{
current_port = location; // traghetto arriva a destinazione
ok2unload.signal(); // da il via per far sbarcare le macchine
ok2ship.wait(); // si ferma
current_port = 0; // traghetto sta viaggiando tra i due porti
}

Procedure entry: imbarca(int location)
{
mutex.wait(); // prende possesso della rampa
ferry.push(1); // sale sul traghetto
mutex.signal(); // libera la rampa
}

Procedure entry: imbarcato(int location)
{
if(ferry.lenght() == MAX) // se il traghetto è pieno da il via per farlo salpare
{
ok2load.wait();
ok2ship.signal();
}
}

Procedure entry: sbarca(int location)
{
mutex.wait(); // prende possesso della rampa
ferry.pop(); // scende dal traghetto
mutex.signal(); // libera la rampa
}

Procedure entry: sbarcato(int location)
{
if(ferry.lenght() == 0) // se il traghetto è vuoto da il via per far imbarcare le macchine
{
ok2unload.wait();
ok2load.signal();
}
}

</syntaxhighlight>
 

=== Esercizio c.1 ===
<syntaxhighlight lang="c">
/* Monitor tmon */

#define MAX n
#define NONE 0
#define TERRAFERMA 1
#define ISOLA 2

condition ok2unload;
condition ok2load[2];
condition ok2ship;
condition empty;

int onboard = 0;
int onramp = 0;
int current_port = NONE;

Procedure entry: al_porto(int location)
{
//arrivando
current_port = location;
ok2unload.signal();
if (onboard > 0)
empty.wait()
ok2load[location].signal()
if (onboard < MAX)
ok2ship.wait()
//partendo
current_port = NONE;
}

Procedure entry: imbarca(int location)
{
if (current_port != location || onramp > 0 || onboard >= MAX)
ok2load[location].wait()
onramp = 1;
}

Procedure entry: imbarcato(int location)
{
onramp = 0; onboard++;
if (onboard < MAX)
ok2load[location].signal();
else
ok2ship.signal();
}

Procedure entry: sbarca(int location)
{
if (current_port != location || onramp > 0)
ok2unload.wait()
onramp = 1;
}

Procedure entry: sbarcato(int location)
{
onramp = 0; onboard--;
if (onboard == 0)
empty.signal();
else
ok2unload.signal();
}
</syntaxhighlight>
 

=== Esercizio c.2 (sbagliato) ===
<syntaxhighlight lang="c">

#define N n // limite operazioni
semaphore mutex(1); // sezione critica

class lim_semaphore()
{
int value;
semaphore plus;
semaphore minus;

P()
{
mutex.P();
if(value < N)
{
if (value >= 0)
{
plus.P();
}
else
{
minus.V();
}
value--;
}
mutex.V();
}

V()
{
mutex.P();
if(value > -N)
{
if (value <= 0)
{
minus.P();
}
else
{
plus.V();
}
value++;
}
mutex.V();
}
}
</syntaxhighlight>
 

=== Esercizio c.2 ===
==== Soluzione "furba e facile" ====
* Visto dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]) in data 18:53, 9 September 2020 (CEST). Ritengo sia: corretto (perché l'ho fatto pressappoco uguale). (Ritengo anche che possedere strumenti di analisi formale per verificare la correttezza di codice simile sarebbe di grande ausilio.)

<syntaxhighlight lang="java">
class bounded_semaphore {
semaphore plus;
semaphore minus;
int value; // serve per significato

bounded_semaphore (int initval, unsigned maxval) {
value = initval;
plus = new semaphore(maxval + initval);
minus = new semaphore(maxval - initval);
}

void P() {
plus.P();
value--;
minus.V();
}

void V() {
minus.P();
value++;
plus.V();
}
}
</syntaxhighlight>

==== Soluzione "schiacciasassi" ====
Controllato da [[LiberaL|https://t.me/llibera]] in data 2023/05/12, perchè nel primo if della V() si fa value >= - maxval? non dovrebbe essere + maxval?

<syntaxhighlight lang="java">
class bounded_semaphore {
semaphore mutex;
queue<semaphore> okmin, okmax;
int value;
unsigned maxval;

bounded_semaphore (int initval, unsigned maxval) {
value = initval;
this.maxval = maxval;
}

void P() {
mutex.P();

if (value <= -maxval) {
s=semaphore(0);
okmin.enqueue(s);
mutex.V();
s.P();
} else if (okmax.length() > 0) {
s = okmax.dequeue()
s.V();
mutex.V();
} else {
value--;
mutex.V();
}
}

void V() {
mutex.P();

if (value >= -maxval) { //qui...
s=semaphore(0);
okmax.enqueue(s);
mutex.V();
s.P();
} else if (okmin.length() > 0) {
s = okmin.dequeue()
s.V();
mutex.V();
} else {
value++;
mutex.V();
}
}
}
</syntaxhighlight>

=== Esercizio g.1 ===
* Controllato dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]), 23:17, 9 September 2020 (CEST). Ritengo sia: corretto

<nowiki>
IC = 10,10,10 // Capitale iniziale
COH = 4,4,4 // Saldo in cassa

MAX ATT RES AVAIL
P1 | 6,6,6 | 1,1,1 | 5,5,5 | 4,4,4
P2 | 6,6,6 | 1,1,1 | 5,5,5 | 5,5,5
P3 | 9,9,9 | 4,4,4 | 5,5,5 | 6,6,6
</nowiki>

Minimizzato

<nowiki>
IC = 4,4,4
COH = 1,1,1

MAX ATT RES
P1 | 3,3,3 | 1,1,1 | 2,2,2
P2 | 3,3,3 | 1,1,1 | 2,2,2
P3 | 3,3,3 | 1,1,1 | 2,2,2
</nowiki>

=== Esercizio g.2 (da controllare) ===

* Visto e rimaneggiato in data 19:40, 10 September 2020 (CEST) dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]])

<hr>

# Il calcolo del working set serve a determinare il numero di processi che possono essere mantenuti attivi sulla base del limite della memoria principale, più precisamente del suo numero di frame. Può essere svolto ad ogni page fault, ossia quando un processo tra quelli attivi richiede una pagina non presente in memoria, o prima di avviare un nuovo processo.
# La lunghezza massima di un file che può essere memorizzato su un file system di tipo FAT viene calcolata moltiplicando il massimo numero di cluster (dimensione dell'unità di allocazione) identificabili per la loro dimensione. Il massimo numero di cluster identificabili dipende da quanti bit sono allocati per numerarli, e per questa distinzione esistono varie versioni di FAT (FAT12, FAT16, FAT32).
## FAT32 memorizza la dimensione dei file in un intero unsigned da 32bit, e non può quindi gestire un file di dimensione superiore ai 2^32 bit = ~4GB.
## FAT16, allocando 16bit per identificare i cluster, può contarne al massimo 2^16 (65536). Prendendo quindi, ad esempio, un file system FAT16 con cluster da 32KB, possiamo avere file grandi al massimo 32KB*65536 = ~2GB.
## FAT12 di conseguenza può numerare al massimo 2^12 (4096) cluster, ma dato che il numero dei settori del disco viene memorizzato in un intero signed a 16bit, la massima dimensione del disco è 2^15 = 32MB. Ovviamente, non si può memorizzare un file di grandezza superiore alla dimensione dell'unità di memorizzazione stessa, e quindi anche i file in FAT12 possono avere dimensione massima di 32MB.
# Entrambi condividono l'intento di infettare host con codice malevolo, ma differiscono fondamentalmente nella modalità: i virus infettano programmi già esistenti mediante un ''virus dropper'', mentre i worm diffondono copie di se stessi, solitamente attraverso la rete.
# In vari casi sulla base della natura del sistema. Innanzitutto, in sistemi batch ciò avviene se non sono stati inseriti più processi per un certo lasso di tempo. In sistemi general-purpose (es. per PC o dispositivi mobili) tale condizione è verificabile se tutti i processi sono in attesa su una coda che non è quella dello scheduler (ad. es. di un semaforo o di una periferica di I/O); casi concreti sono pertanto il deadlock (di tutti i processi del sistema) o attesa generale di I/O. Infine sempre in sistemi general-purpose tale condizione può manifestarsi, stavolta in condizioni patologiche, se ogni processo è assegnato ad una propria CPU/core, lasciando pertanto la coda d'attesa vuota.

= Esame 28/05/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.05.28.tot.pdf 2018.05.28.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
Stack<int> entriesStack;

int vid[MAX];
condition ok2esci[MAX]
int in = 0;
int out = -1;

Procedure-entry: entra(int id) {
if (in >= MAX)
ok2entra.wait()
vid[in++] = id;
if (in < MAX)
ok2entra.signal()
else
out = MAX - 1;
}

Procedure-entry: esci(int id) {
int i;
for (i = 0; i < in; i++)
if (vid[i] == id)
break; //cerco l'indice di id nel vettore vid

if (i != out)
ok2esci[i].wait();

if (out > 0) {
out--;
ok2esci[out].signal();
} else {
out--;
in = 0;
ok2entra.signal();
}
}
</syntaxhighlight>
 

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">
Monitor riempisvuota {
Int MAXPROCESSI;
Stack s;
condition ok2enter;
condition ok2exit;

p.e void entra(getPid()){
if( s.size() >= MAXPROCESSI)
ok2enter.wait();
s.insert(getPid());
if(s.size() > MAXPROCESSI)
ok2exit.signal()
}

p.e void esci(getPid()){
if(s.size() > MAXPROCESSI && s.top == getPid()) {
s.pop();
ok2entra.signal()
}
else
ok2exit.wait();
}
</syntaxhighlight>
 
=== Esercizio c.2 (ERRATO) ===

* Soluzione proposta è errata, non puoi riceve in modo greedy e printare subito il carattere [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 11:33, 18 January 2023 (CET)

<syntaxhighlight lang="c">
proc[x]: x='a',...,'z'
while True:
//c sarà il carattere stampato dal processo precedente
(c, string) = arecv(*)
if(string == wait){
//mi metto in attesa di ricevere l'ACK da proc[x]
m=arecv(x);
}
if (c == NONE){
//significa che sei il primo a ricevere quella stringa
print(x);
if (len(string) > 1){
//mando la wait a tutti, il primo che riceve qualcosa da stampare manda una wait a tutti
asend(wait,*);
int l = len(string);
int i = 1;
while(l != 0){
asend(proc[string[i]], (x, string[i...]));
//si mette in attesa di ricevere l'ACK dal processo dell'ultima lettera della parola
m=areceive(proc[string[i]]);
//rimando la wait al processo per ribloccarlo
asend(wait, proc[string[i]])
l--;
i++;
}
//dopo aver finito la stampa della stringa sblocco tutti i processi
asend(ACK, *);
}
}else{
print(x);
asend(ACK, x);
//ricomincia il ciclo while, si rimette in attesa e il 'gestore gli rimanda la wait'
}
</syntaxhighlight>
 

=== Esercizio c.2 ===
[[User:Flecart|Flecart friend]] ([[User talk:Flecart|talk]]) cedo la proprità intellettuale di questa soluzione a flecart

<syntaxhighlight lang="c">
process [x]: x='a'..'z'
if(x=='a'){
asend(<NULL,NULL>,'b');
asend(<NULL,NULL>,'b');
}
While True:
<c,string>=arecv(x-1+26%26);
if(string==NULL):
<c,string>=arecv(*);
if(string!=NULL):
<c,string>=arecv(x-1+26%26);

if(string!=NULL):
if(string[0]==x):
print(string[0]);
if(string.len()>1):
aasend(<NULL,string[1:]>,(x+1)%26);
else:
aasend(<NULL,NULL>,(x+1)%26);
aasend(<NULL,NULL>,(x+1)%26);
else:
aasend(<NULL,string>,(x+1)%26);
else:
aasend(<NULL,NULL>,(x+1)%26);
aasend(<NULL,NULL>,(x+1)%26);

</syntaxhighlight>

=== Proposta c2 ===
* Proposto [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 11:31, 18 January 2023 (CET)

<syntaxhighlight lang="C">
proc[a]:
bool occupied = false;
queue<string> s;

while True {
(c, string) = arecv(*);

if (c == NONE) {
if (occupied) {
s.enqueue(string);
} else {
if (string.len() < 1)
continue;

occupied = true;
asend(string[0], (MIDDLE, string));
}
} else if (c == END) {
if (s.size() > 0) {
string ss = s.dequeue();
asend(string[0], (MIDLLE, string));
} else {
occupied = false;
}
} else {
print(x);
if (len(string) > 1)
asend(proc[string[0]], (MIDDLE, string[1:]));
else:
asend(proc[a], (END, ""));
}
}

proc[x]: x = 'b', ... 'z';
while True {
(c, string) = arecv(*);
if (c == NONE) {
asend(proc['a'], (NONE, string));
} else { // potrà essere solo MIDDLE
print(x);
if (len(string) > 1)
asend(proc[string[0]], (MIDDLE, string[1:]));
else:
asend(proc[a], (END, ""));
}
}
</syntaxhighlight>

= Esame 12/02/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.02.12.tot.pdf 2018.02.12.tot.pdf]

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">

monitor bridge:

int ncar
bool boat_on_0
bool boat_on_1 // per semplicità, quando nel codice si trova boat_on_(direction) oppure isBoat(direction)(),
// si valuta il valore booleano di direction e lo si applica sotto forma di stringa al simbolo
// ad esso adiacente
bool is_raised
queue waiting_mean // i valori possibili sono: boat0, boat1 oppure car
condition ok2go

entry car_enter(direction):
if is_raised || ncar == MAXCAR:
waiting_mean.enqueue(car)
ok2go.wait()
is_raised = false
++ncar

entry car_exit(direction):
--ncar
if (waiting_mean.top().isBoat() && ncar == 0) || waiting_mean.top().isCar(): // isBoat ritorna true se l'oggetto su cui
waiting_mean.dequeue() // è invocata è boat0 oppure boat1
ok2go.signal()

entry boat_enter(direction):
if !is_raised || boat_on_(direction):
waiting_mean.enqueue(boat)
ok2go.wait()
if waiting_mean.top().isBoat(!direction)():
waiting_mean.dequeue()
ok2go.signal()
is_raised = true
boat_on_(direction) = true

entry boat_exit(direction):
boat_on_(direction) = false
if !boat_on_(!direction):
waiting_mean.dequeue()
ok2go.signal()

</syntaxhighlight>

 

=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor bridge {
int carsOnBridge = 0;
int shipping[2] = {0, 0}; //navi da entrambe le direzioni
int status = NONE; //UP DOWN NONE
int last2pass = 0; //ultimo che ha passato il ponte
int waitingC = 0; //coda delle macchine che aspettano
int waitingS[2] = {0,0}; //navi che stanno aspettando

condition ok2ship[2]
condition ok2drive

entry car_enter(int direction){
if(carsOnBridge >= MAX || status == UP || waitingS[0] + waitingS[1] > 0 ){
waitingC++;ok2drive.wait;waitingC--;}
status = DOWN;
carsOnBridge++
if (carsOnBridge < MAX)
ok2drive.signal(); //vanno tutte le MAX car che stanno aspettando
}
entry car_exit(int direction){
carsOnBridge--
if (waitingS[0] + waitingS[1] == 0)
ok2drive.signal();
if(carsOnBridge == 0){
ok2ship[0].signal(); ok2ship[1].signal();
}
if(carsOnBridge + waitingS[0] + waitingS[1] == 0)
status = NONE
}

entry ship_enter(int direction){
if (bridge = DOWN || shipping[direction] != 0 || waitingC > 0)
{
waitingS[i]++; ok2ship[i].wait(); waitingS[i]--;
}
isBridgeUp = false;
shipping[i] = 1;

entry ship_exit(int direction){
shipping[i] = 0;
if (waitingC == 0)
ok2ship[i].signal()
else if(shipping[1-i] == 0)
ok2drive.signal();
if(carsOnBridge + waitingS[0] + waitingS[1] == 0)
status = NONE
}
</syntaxhighlight>

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">
monitor bridge {

UP=0;
DOWN=1;
bridgeis = DOWN;

bool carAreExiting = false;

condition ok2drive;
condition ok2barca[2];

waitingCar = 0;
carOnBridge = 0;

boatWaiting[2] = {0,0};
boatIsPassing[2] = {false,false}

entry car_enter(direction) {

if (bridgeis == DOWN)
if(carOnBridge == MAXCAR)
waitingCar++;
ok2drive.wait();
waitingCar--;
else if (carAreExiting)
waitingCar++;
ok2drive.wait();
waitingCar--;
else
if (boatIsPassing[0] || boatIsPassing[1])
waitingCar++;
ok2drive.wait();
waitingCar--;
bridgeis = DOWN;

carOnBridge++;
carAreExiting = false;
if(carOnBridge < MAXCAR && !carAreExiting)
ok2drive.signal();

}

entry car_exit(direction) {

carOnBridge--;
carAreExiting = true;

if(carOnBridge == 0)
carAreExiting = false;
if(boatWaiting[0] > 0)
bridgeis = UP;
ok2barca[0].signal();
else if (boatWaiting[1] > 0)
bridgeis = UP;
ok2barca[1].signal();
else
ok2drive.signal();
}

entry boat_enter(direction) {

if (bridgeis == UP)
| if (boatIsPassing[direction] == true)
| | boatWaiting[direction]++;
| | ok2barca.wait();
| | boatWaiting[direction]--;
else
| if (carOnBridge > 0)
| | boatWaiting[direction]++;
| | ok2barca.wait();
| | boatWaiting[direction]--;
| | bridgeis = UP;

boatIsPassing[direction] = true;

if(boatIsPassing[1-direction] == false && boatWaiting[1-direction] > 0)
ok2barca[1-direction].signal();

}

entry boat_exit(direction) {

boatIsPassing[direction] = false;

if (boatIsPassing[1-direction] == false)
if (waitingCar > 0)
bridgeis = DOWN;
ok2drive.signal();
else
if (waitingCar == 0)
ok2barca[direction].signal();

}
</syntaxhighlight>

=== Esercizio c.1 (sbagliato) ===
<syntaxhighlight lang="c">
monitor bridge
condition ok2passCar;
condition ok2passBoat;
condition ok2up;
condition ok2down;
int carOnBridge[2] = 0; //2 sensi di marcia
int boatUnderBridge[2] = 0;
boolean bridge_down = false; //vuol dire che il ponte parte alzato, true ponte abbassato

procedure entry car_enter(direction){
if(bridge_down && carOnBridge[direction] < MAXCAR){
carOnBridge[direction]++;
ok2passCar.signal();
}else if (bridge_down && boatUnderBridge[0] == 0 && boatUnderBridge[1] == 0){
//se non ci sono navi in transito e arriva una macchina abbassa ponte
ok2down.signal();
ok2passCar.signal();
ok2passBoat.wait();
}else{
ok2passCar.wait();
}
}

procedure entry car_exit(direction){
carOnBridge[direction]--;
if(carOnBridge[0] == 0 && carOnBridge[1] == 0){
bridge_down = false;
ok2up.signal();
}else{
ok2up.wait();
}
}

procedure entry boat_enter(direction){
if(!bridge_down && boatUnderBridge[direction] < 1){
boatUnderBridge[direction]++;
ok2passBoat.signal();
}else if(!bridge_down && carOnBridge[0] == 0 && carOnBridge[1] == 0){
ok2up.signal();
ok2passBoat.signal();
ok2passCar.wait();
}else {
ok2passBoat.wait();
}
}

procedure entry boat_exit(direction){
boatUnderBridge[direction]--;
if(boatUnderBridge[0] == 0 && boatUnderBridge[1] == 0){
bridge_down = true;
ok2down.signal();
}else{
ok2down.wait();
}
}
</syntaxhighlight>

=== Esercizio c.1 2o (sbagliato) ===
<syntaxhighlight lang="c">
#define car 1
#define ship 2
#define fromDX 1
#define fromSX 0

monitor bridge {
int carsOnBridge = 0;
int shippingDX = 0; //nave che sta passando dal lato destro
int shippingSX = 0; //nave che sta passando dal lato sinistro
bool isBridgeUp = false;
int last2pass = 0; //ultimo che ha passato il ponte
int waitingS = 0; //navi che stanno aspettando
int waitingC = 0 ; //auto che stanno aspettando

condition ok2ship
condition ok2drive

entry car_enter(int direction){
//un auto si ferma se il numero di auto sul ponte è massimo
//e se l'ultima a passare è stata un auto mentre ci sono navi in attesa
if(carsOnBridge == MAX || isBridgeUp || (last2pass==car && waitingS > 0) ){
waitingC++;
ok2drive.wait;
}
carsOnBridge++;
waitingC--;
}

entry car_exit(int direction){
carsOnBridge--;
last2pass = car;
if(carsOnBridge == 0 && waitingS>0){
isBrigdeUp = true;
ok2ship.signal;
}
}

entry ship_enter(int direction){
//se la barca viene da destra
if(direction == fromDX){
//si ferma anche quando c'è una nave che sta già attraversando nella sua stessa direzione
if (isBridgeup == false || shippingDX || (last2pass==ship && waitingC > 0) ){
waitingS++;
ok2ship.wait;
}
if (waitingS > 0)
waitingS--;
shippingDX = 1;
}
//se la barca viene da sinistra
else if(direction == fromSX){
if (isBridgeup == false || shippingSX || ( (last2pass==ship && waitingC > 0))){
waitingS++;
ok2ship.wait;
}
if (waitingS > 0)
waitingS--;
shippingSX = 1;

}
}

entry ship_exit(int direction){
if(direction == fromDX)
shippingDX = 0;
else if (direction == fromSX)
shippingSX = 0;
last2pass = ship;
if(shippingDX == 0 && shippingSX == 0 && waitingC)
isBrigdeUp == false;
ok2drive.signal;
else if(shippingDX == 0 && shippingSX == 0 && waitingS > 0)
ok2ship.signal;
}
}
</syntaxhighlight>

=== Esercizio c.2 (sbagliato) ===

# (Ri)Controllato dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]) in data 26/08/2020

<syntaxhighlight lang="python">
list printed_msg; # questa è una variabile condivisa che ai fini dell'esercizio non si può utilizzare (message passing)

process server[i]:
while true:
<msg, pid> = arecv(*)

if printed_msg.length == 0 or <msg, pid> is not in printed_msg:
printed_msg.append(<msg,id>)
print(msg)
</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
Nello svolgimento seguente, receiver incapsula l'ambiente privato del processo; _peers rappresenta il vettore di processi "fratelli" ai quali può essere chiesto di stampare un messaggio, mentre _printed contiene l'hash di tutti i messaggi stampati dal processo locale. Si suppone che istanze della classe receiver possano essere passate come parametro ad areceive() ed asend() (non implementate).

<syntaxhighlight lang="python">
class receiver:
def __init__(self, peers):
"""
:param peers: list of processes this process communicates with.
"""
self._peers = tuple(peers)
self._printed = list()

def run(self):
while True:
process, message = areceive(ANY)

if process in self._peers:
self._reply_query(process, message)
else:
self._print(process, message)

def _print(self, sender, message):
h = hash(message.text)

if h not in self._printed and not self._printed_from_peers(message):
self._printed.append(h)
print(message.text)

def _reply_query(self, sender, h):
"""
Invoked when the current process receive a "query" from a peer process.
`h` contains the hash of a message which may or may have not been
sent from this process; if it was sent, the reply is `Yes`, otherwise `No`.
"""
reply = "Yes" if int(h) in self._printed else "No"
asend(sender, reply)

def _printed_from_peers(self, message):
"""
:return: `True` if this message has already been printed from any of the
peer processes, `False` otherwise.
"""
h = hash(message)

for p in self._peers:
asend(p, str(h))

for p in self._peers:
_, reply = areceive(p)

if reply.text == "Yes":
return True
else if reply.text != "No":
# If the response is neither "Yes" nor "No", then we have got a query
self._reply_query(p, reply)

return False
</syntaxhighlight>

=== Esercizio g.1 (da controllare) ===
Sulla base dei valori in entrata, è possibile costruire le matrici Allocation (q.tà di risorse allocate per processo e per tipo), Need (q.tà di risorse che ogni processo potrebbe ancora chiedere) e il vettore Available (num. di risorse correntemente disponibili).

{| class="wikitable" style="float: left"
! colspan=3 | Allocation
|-
! !! A !! B
|-
| p1 || 4 || 5
|-
| p2 || 3 || 3
|-
| p3 || 2 || 4
|}

{| class="wikitable" style="float: left; margin-left: 1em"
! colspan=3 | Need
|-
! !! A !! B
|-
| p1 || 6 || 8
|-
| p2 || 6 || 3
|-
| p3 || 6 || 8
|}

{| class="wikitable" style="float: left; margin-left: 1em"
! colspan=2 | Available
|-
! A !! B
|-
| x || y
|}

 

Nel caso delle risorse di tipo A, deve aversi x >= 6 in quanto un processo dovrà essere selezionato come primo nella permutazione dell'algoritmo del banchiere multivaluta, e tutti quelli correnti hanno lo stesso valore Need(i)(1); per ciò che riguarda le risorse di tipo B, possiamo ragionare per esaustione

* Se il primo processo della permutazione è p1, allora y >= 8 (con questo valore posso soddisfare la richiesta di p1 e in seguito tutte le altre)
* Se il primo processo della permutazione è p2, allora y >= 5: con questo valore è possibile soddisfare la richiesta di p2; una volta che esso avrà finito, restituirà 3 unità della risorsa B, che permetteranno di soddisfare sia le richieste di A sia quelle di C
* Se il primo processo della permutazione è p3, allora y >= 8 (ragionamento analogo come per p1)

Volendo scegliere il minimo, y >= 5, ed in conclusione (x, y) >= (6, 5).

''Svolgimento basato in parte sull'approccio di Operating System Concepts di Silberschatz. et al, 9th edition, cap. 7.''

=== Esercizio g.2 (da controllare) ===
# Può accadere che il sistema torni in uno stato di safety o che invece porti a deadlock. Diversamente uno stato di safety non può portare direttamente ad uno stato di deadlock, ma solo ad uno di non-safety.
# Selezionare uno o più tra i processi attivi e sospenderli, salvando il loro stato su memoria secondaria operando delle operazioni di swap-out, finché l'insieme dei frame nella memoria centrale non è in grado di soddisfare tutti i processi rimasti attivi.
# La scelta è determinata perlopiù dal fattore costo. Con un sistema RAID 1 è possibile ripristinare un disco guasto molto brevemente, in quanto le operazioni coinvolte prevedono una semplice ricopiatura dal disco di backup; con un sistema RAID 5 il ripristino del disco guasto deve coinvolgere tutti i dischi dell'intero array, e ciò può richiedere anche ore per dischi di grandi dimensioni. D'altra parte RAID 1 è più costoso (con n dischi, posso memorizzare tanta informazione quanto potrei con n / 2 dischi) rispetto a RAID 5 dove, tra gli n dischi, complessivamente soltanto uno è destinato alle informazioni di ridondanza.
# ''Completare.''

Prove scritte 2018

2023-05-12T14:39:00Z

LiberaL: /* Soluzione "schiacciasassi" */

= Esame 19/09/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.09.19.tot.pdf Testo dell'esame].

=== Esercizio c.2 (da controllare) ===

* Controllato dall'utente ? in data ?
* ...

Nello pseudocodice seguente, il termine this fa riferimento al processo corrente, mentre ANY ad uno qualunque.

<syntaxhighlight lang="c">
stack<message> messages;

void lifo_send(string m, process dest) {
do {
asend(m, dest);
} while (areceive(dest).text != "ACK");
}

message lifo_receive(process source) {
if (source != ANY) {
message m = areceive(source);

asend("ACK", source);

return m;
} else {
message m;

asend("END", this);
m = areceive(ANY);

while (m.text != "END" || m.sender != this) {
messages.push(m);
asend("ACK", m.sender);

m = areceive(ANY);
}

/* Bisogna tenere conto dei casi in cui lifo_receive() viene invocata quando nessun
* messaggio è stato ancora spedito da altri processi. In tal caso si attende il
* il primo e lo si restituisce.
*/
if (messages.empty()) {
m = areceive(ANY);
asend("ACK", m.sender);

return m;
} else {
return messages.pop();
}
}
}
</syntaxhighlight>

= Esame 17/07/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.07.17.tot.pdf 2018.07.17.tot.pdf]
== Esercizio c.1 ==
A Bruxelles c'è un locale chiamato Delirium Café. Alla vigilia del FOSDEM tutti gli anni gli sviluppatori europei di
software libero si ritrovano a bere birra (il locale è nel guinnes dei primati con più di duemila tipi di birra). Il prossimo appuntamento è
fissato per il 1 febbraio 2019 ore 20. Numerosi sono i tipi di birra alla spina. I baristi (tanti) prendono gli ordini (es. mezza pinta, 1 o 2
pinte) e riempiono i bicchieri. Quando un fusto e' vuoto avvertono i magazzinieri che prendono un nuovo fusto che contiene più di
cento pinte e lo sostituiscono, a questo punto il barista può completare il riempimento del bicchiere.
La vita di un barista del Delirium è:
while True:
(type, quantity) = get_order()
delirium.pour(type, quantity)
La vita di un Magazziniere è:
while True:
type = delirium.isempty()
capacity = change_keg(type)
delirium.loaded(type, capacity)

Attenzione: se il fusto (keg) è quasi vuoto il barista dovrà riempire parzialmente il bicchiere, occorrerà attivare il magazziniere che
cambierà il fusto e poi il barista riempirà il bicchiere fino alla quantità richiesta dal cliente. Mentre un barista sta attendendo il
cambiamento di un fusto altri baristi potrebbero ricevere ordini per lo stesso tipo di birra: gestire opportunamente questo caso.
Scrivere il monitor Delirium.

=== Proposta di soluzione 1 ===
* ERRORE: Secondo me c'è un leggero errore nella parte di load, nel caso in cui la nuova pinta non riesca a soddisfare completamente la richiesta ossia quando vale availableBeer[t] <= requests[t].head(), allora non lo risveglio nemmeno, invece dovrei risvegliare il pour, fargli versare quanto può, e richiedere una altra pinta, perché questo era un requisito del problema. [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 12:00, 15 January 2023 (CET)

<syntaxhighlight lang="c">
/* Monitor Delirum: */

// Condition: Ok2Load;
// Condition: Ok2Pour[]; // Un elemento per Type
int availableBeer[]; // Un elemento per Type
Queue requests[]; // Un elemento per Type
Queue pendingRequests;

Procedure entry: void Pour(Type t, Quantity c)
{
if (c > availableBeer[t]) // Richiesta maggiore della birra disponibile
{
c -= availableBeer[t];
availableBeer[t] = 0;
requests[t].Enqueue(c);
if (requests[t].Length == 1) // Risveglio un magazziniere solo se è la prima richiesta di questo tipo di birra
{
pendingRequests.Enqueue(t);
Ok2Load().Signal();
}
Ok2Pour[t].Wait();
requests[t].Dequeue(); // Quando ho ottenuto la birra che voglio, elimino la mia richiesta
}
availableBeer[t] -= c;
}

Procedure entry: Type isEmpty()
{
if (pendingRequests.Length == 0)
{
Ok2Load.Wait();
}
return pendingRequests.Dequeue();
}

Procedure entry: Loaded(Type t, Capacity c)
{
availableBeer[t] += c;
while (requests[t].Length > 0 && availableBeer[t] > requests[t].head())
{
Ok2Pour[t].Signal();
}

if (requests[t].Length > 0) // serve per evitare che a causa di un magazziniere lento si accodino cosi tante richieste che mentre si sta caricando si svuota subito il fusto
{
pendingRequests.Enqueue(t);
Ok2Load.Signal();
}
}
</syntaxhighlight>

=== Proposta di soluzione 2 ===
* Proposto da [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 13:41, 15 January 2023 (CET)
<syntaxhighlight lang="C">
extern int MAX_TYPE;
class Delirium {
int keg[MAX_TYPE]; // qnty fusto attuale
int orders[MAX_TYPE]; // qnty richiesta
bool worked[MAX_TYPE]; // 1 se magazziniere sta lavorando su questo.

condition type_wait[MAX_TYPE];
int num_wait[MAX_TYPE];

queue<int> empty_type;
condition is_empty;

entry pour(type, quantity) {
while (keg[type] < quantity) {
quantity -= keg[type];
keg[type] = 0;
if (!empty_type.find(type) && !worked[type]) {
empty_type.enqueue(type);
is_empty.signal();
}

num_wait[type]++;
type_wait[type].wait();
num_wait[type]--;
}
keg[type] -= quantity;
quantity = 0; // questo è inutile, ma concettualmente è corretto, l'ordine è completato.
}

entry loaded(type, capacity) {
keg[type] += capacity;
worked[type] = false;

for (int i = num_wait[type]; i > 0; i--) {
type_wait[type].signal();
}
}

// si suppone che un singolo tipo di fusto è lavorabile da un solo magazziniere alla volta.
// worked impedisce di avere nella coda un fusto su cuisi sta già lavorando.
entry isempty() {
if (empty_type.size() <= 0) {
is_emtpy.wait();
}
int type = emtpy_type.dequeue();
worked[type] = true;
return type;
}
}
</syntaxhighlight>

== Esercizio c.2 ==

=== Proposta di soluzione 1 ===
* Visto e corretto dall'utente [[User:Acsor|Acsor]] in data 23/08/2020
* Visto e corretto dall'utente ? in data ?
* Visto, ritenuto corretto [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 09:27, 15 January 2023 (CET)

<syntaxhighlight lang="c">
class LIFOBuffer {
stack<T> s;
semaphore mutex(1); // mutua esclusione
semaphore ok2consume(0);

void push (T value) {
mutex.P();
s.push(value);
// (1)
mutex.V()

ok2consume.V() // Curiosità: che succede se spostiamo quest'istruzione in (1)? Edit: funziona lo stesso, solo che aggiorni il valore del semaforo prima di uscire dalla mutex.
}

T pop () {
T value;

ok2consume.P();
mutex.P();
value = s.pop();
mutex.V();

return value;
}
}
</syntaxhighlight>

=== Proposta di soluzione 2 ===
Proposto da [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 09:27, 15 January 2023 (CET)

<syntaxhighlight lang="C">
class lifobuf {
semaphore mutex(1);
stack<int> values; // empty initialized
stack<semaphore> waiting;

push(int value) {
mutex.P();
values.push(value);
if (waiting.size() > 0) {
semaphore s = waiting.pop();
s.V();
return;
}

mutex.V();
}

pop() {
int ret_val;
mutex.P();
if (values.size() <= 0) {
semaphore s = new semaphore(0);
waiting.push(s);
mutex.V();
s.P();
free(s);
}

ret_val = values.pop();
mutex.V();

return ret_val;
}
}
</syntaxhighlight>

== Esercizio g.1 ==
Possiamo notare subito che il sistema ha due processori ed un dispositivo di I/O.
'''A''' e '''B''' partono insieme al tempo 0. 
'''C''' parte tra il tempo 0 ed il tempo 2 (non possiamo sapere di preciso quando perchè entrambe le CPU sono occupate). 
'''D''' parte tra il tempo 0 ed il tempo 3. 
A questo punto possiamo supporre che tutti e 4 i processi partano in sequenza ('''A''', '''B''', '''C''', '''D''') nello stesso momento, e ognuno prende la prima CPU libera che trova. 
'''A''' lavora per 3ms, poi scade il time slice. 
Nel frattempo '''B''' lavora per 2ms, poi richiede I/O per 4ms. 
La CPU su cui lavora '''B''' quindi si libera, e si manda in esecuzione il processo '''C'''. 
Scaduto il time slice per '''A''', si da il controllo ad un nuovo processo. '''B''' è occupato con I/O, '''C''' sta già lavorando, quindi è il turno di '''D'''. 
'''C''' lavora per 3ms, poi richiede I/O per 3ms, che però è occupato da '''B''', quindi si mette in coda per utilizzarlo. 
La CPU su cui lavorava '''C''' si libera ed il controllo torna ad '''A''', che doveva lavorare ancora per 2ms prima di chiedere il controllo di I/O, quindi lavora e si mette in coda dietro a '''C'''. 
Tornando a '''D''', questo lavora per 3ms prima che scada il time slice. Anche '''B''' ha finito il lavoro e ha bisogno di una CPU. 
In questo momento sia '''D''' che '''B''' sono nella coda dei processi in stato ready, ma dal diagramma possiamo notare che il controllo torna a '''D'''. 
La CPU ha scelto a caso un processo tra i due, perchè arrivati a questo punto possiamo supporre che lo scheduler sia Round-Robin. 
'''B''' prende possesso della prima CPU che si libera, ovvero quella occupata da '''A''', poi lavora per 2ms e termina il suo lavoro. 
Nel momento in cui '''B''' termina il lavoro, scade anche il time slice per '''D''', e '''C''' termina di usare I/O. 
Abbiamo due processi ('''C''' e '''D''') in coda ready. Ma abbiamo anche due CPU libere, perchè '''A''' è in coda per I/O e ci entra appena '''C''' finisce di usarlo. 
Lo scheduler sceglie di mandare '''C''' sul primo processore e '''D''' sul secondo. 
'''A''' nel frattempo, lavora per 4ms con I/O. 
'''C''' lavora per 3ms, poi termina il suo lavoro. 
'''D''' lavora per 3ms, poi scade il time slice. Ci sono due processori liberi, quindi '''D''' riparte subito in esecuzione. 
'''D''' doveva lavorare ancora per 1ms prima di aver bisogno di I/O, quindi finisce e si mette in coda. 
Ma nello stesso momento '''A''' termina di usare I/O, si prende un processore libero e lavora per i suoi ultimi 2ms. 
'''D''' lavora per 1ms con I/O, poi prende il secondo processore libero e lavora per 1ms prima di terminare il suo lavoro. 

Il time slice è di 3ms, lo scheduler è di tipo Round-Robin. 
Il dispositivo di I/O è FIFO. L'ordine con cui partono i processi è quello alfabetico.

<syntaxhighlight lang="c">
A(){
compute_a1(); // 5ms
io_a(); // 4ms
compute_a2(); // 2ms
}

B(){
compute_b(); // 2ms
io_b(); // 4ms
compute_b(); // 2ms
}

C(){
compute_c(); // 3ms
io_c(); // 3ms
compute_c(); // 3ms
}

D(){
compute_d1(); // 10ms
io_d(); // 1ms
compute_d2(); // 1ms
}
</syntaxhighlight>
Lo scheduler potrebbe anche essere a priorità: 
Priorità '''B''' < priorità '''D''' < priorità '''C''' 
Priorità '''A''' = ? 
'''B''' fatto partire prima di '''C''' e '''D'''.
 

== Esercizio g.2 (da controllare) ==
# In sistemi dove dispositivi di archiviazione o supporti hardware per la memoria virtuale (e dunque per la paginazione, spesso utilizzata per realizzare il supporto di memoria virtuale) non sono presenti (es. sistemi embedded). ''(In sistemi real-time la memoria virtuale è praticabile? Annotare.)''
# Perchè ad esempio sulle chiavette USB quasi mai abbiamo il problema di dover utilizzare file di dimensione maggiore ai 4GB. Non utilizza il journaling, che richiede molteplici scritture per ogni azione ed in dispositivi portatili può ridurre di molto la durata. Non supporta i permessi sui file, e questo è un vantaggio per le chiavette USB, pensate per trasferire dati tra PC diversi.
# Per fornire parallelismo e ridondanza. Non è necessario fare backup dei dati sul disco, nel senso di mantenere una copia identica di dati già memorizzati altrove, in quanto diversi sistemi di codici permettono il rilevamento e/o la correzione di errori.
# Se in un grafo di Holt multirisorsa esiste un ciclo tra più processi e risorse, ciò non significa che allo stesso tempo non siano coinvolti processi con archi esclusivamente entranti. Ogni processo appartenente a questa categoria non è in attesa di risorse, e può dunque procedere con i suoi calcoli; quando avrà terminato rilascerà le risorse precedentemente allocategli, eventualmente sbloccando uno dei processi coinvolti nel ciclo.

= Esame 21/06/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.06.21.tot.pdf 2018.06.21.tot.pdf]
=== Esercizio c.1 (sbagliato) ===
<syntaxhighlight lang="c">
/* Monitor tmon */

define MAX n;
define TERRAFERMA 1;
define ISOLA 2;

semaphore ok2unload;
semaphore ok2load;
semaphore ok2ship;
semaphore mutex(1); // la rampa è zona critica --> mutua esclusione

stack ferry;
int current_port = 0;

Procedure entry: al_porto(int location)
{
current_port = location; // traghetto arriva a destinazione
ok2unload.signal(); // da il via per far sbarcare le macchine
ok2ship.wait(); // si ferma
current_port = 0; // traghetto sta viaggiando tra i due porti
}

Procedure entry: imbarca(int location)
{
mutex.wait(); // prende possesso della rampa
ferry.push(1); // sale sul traghetto
mutex.signal(); // libera la rampa
}

Procedure entry: imbarcato(int location)
{
if(ferry.lenght() == MAX) // se il traghetto è pieno da il via per farlo salpare
{
ok2load.wait();
ok2ship.signal();
}
}

Procedure entry: sbarca(int location)
{
mutex.wait(); // prende possesso della rampa
ferry.pop(); // scende dal traghetto
mutex.signal(); // libera la rampa
}

Procedure entry: sbarcato(int location)
{
if(ferry.lenght() == 0) // se il traghetto è vuoto da il via per far imbarcare le macchine
{
ok2unload.wait();
ok2load.signal();
}
}

</syntaxhighlight>
 

=== Esercizio c.1 ===
<syntaxhighlight lang="c">
/* Monitor tmon */

#define MAX n
#define NONE 0
#define TERRAFERMA 1
#define ISOLA 2

condition ok2unload;
condition ok2load[2];
condition ok2ship;
condition empty;

int onboard = 0;
int onramp = 0;
int current_port = NONE;

Procedure entry: al_porto(int location)
{
//arrivando
current_port = location;
ok2unload.signal();
if (onboard > 0)
empty.wait()
ok2load[location].signal()
if (onboard < MAX)
ok2ship.wait()
//partendo
current_port = NONE;
}

Procedure entry: imbarca(int location)
{
if (current_port != location || onramp > 0 || onboard >= MAX)
ok2load[location].wait()
onramp = 1;
}

Procedure entry: imbarcato(int location)
{
onramp = 0; onboard++;
if (onboard < MAX)
ok2load[location].signal();
else
ok2ship.signal();
}

Procedure entry: sbarca(int location)
{
if (current_port != location || onramp > 0)
ok2unload.wait()
onramp = 1;
}

Procedure entry: sbarcato(int location)
{
onramp = 0; onboard--;
if (onboard == 0)
empty.signal();
else
ok2unload.signal();
}
</syntaxhighlight>
 

=== Esercizio c.2 (sbagliato) ===
<syntaxhighlight lang="c">

#define N n // limite operazioni
semaphore mutex(1); // sezione critica

class lim_semaphore()
{
int value;
semaphore plus;
semaphore minus;

P()
{
mutex.P();
if(value < N)
{
if (value >= 0)
{
plus.P();
}
else
{
minus.V();
}
value--;
}
mutex.V();
}

V()
{
mutex.P();
if(value > -N)
{
if (value <= 0)
{
minus.P();
}
else
{
plus.V();
}
value++;
}
mutex.V();
}
}
</syntaxhighlight>
 

=== Esercizio c.2 ===
==== Soluzione "furba e facile" ====
* Visto dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]) in data 18:53, 9 September 2020 (CEST). Ritengo sia: corretto (perché l'ho fatto pressappoco uguale). (Ritengo anche che possedere strumenti di analisi formale per verificare la correttezza di codice simile sarebbe di grande ausilio.)

<syntaxhighlight lang="java">
class bounded_semaphore {
semaphore plus;
semaphore minus;
int value; // serve per significato

bounded_semaphore (int initval, unsigned maxval) {
value = initval;
plus = new semaphore(maxval + initval);
minus = new semaphore(maxval - initval);
}

void P() {
plus.P();
value--;
minus.V();
}

void V() {
minus.P();
value++;
plus.V();
}
}
</syntaxhighlight>

==== Soluzione "schiacciasassi" ====
Controllato da [LiberaL](https://t.me/llibera) in data 2023/05/12, perchè nel primo if della V() si fa value >= - maxval? non dovrebbe essere + maxval?

<syntaxhighlight lang="java">
class bounded_semaphore {
semaphore mutex;
queue<semaphore> okmin, okmax;
int value;
unsigned maxval;

bounded_semaphore (int initval, unsigned maxval) {
value = initval;
this.maxval = maxval;
}

void P() {
mutex.P();

if (value <= -maxval) {
s=semaphore(0);
okmin.enqueue(s);
mutex.V();
s.P();
} else if (okmax.length() > 0) {
s = okmax.dequeue()
s.V();
mutex.V();
} else {
value--;
mutex.V();
}
}

void V() {
mutex.P();

if (value >= -maxval) { //qui...
s=semaphore(0);
okmax.enqueue(s);
mutex.V();
s.P();
} else if (okmin.length() > 0) {
s = okmin.dequeue()
s.V();
mutex.V();
} else {
value++;
mutex.V();
}
}
}
</syntaxhighlight>

=== Esercizio g.1 ===
* Controllato dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]), 23:17, 9 September 2020 (CEST). Ritengo sia: corretto

<nowiki>
IC = 10,10,10 // Capitale iniziale
COH = 4,4,4 // Saldo in cassa

MAX ATT RES AVAIL
P1 | 6,6,6 | 1,1,1 | 5,5,5 | 4,4,4
P2 | 6,6,6 | 1,1,1 | 5,5,5 | 5,5,5
P3 | 9,9,9 | 4,4,4 | 5,5,5 | 6,6,6
</nowiki>

Minimizzato

<nowiki>
IC = 4,4,4
COH = 1,1,1

MAX ATT RES
P1 | 3,3,3 | 1,1,1 | 2,2,2
P2 | 3,3,3 | 1,1,1 | 2,2,2
P3 | 3,3,3 | 1,1,1 | 2,2,2
</nowiki>

=== Esercizio g.2 (da controllare) ===

* Visto e rimaneggiato in data 19:40, 10 September 2020 (CEST) dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]])

<hr>

# Il calcolo del working set serve a determinare il numero di processi che possono essere mantenuti attivi sulla base del limite della memoria principale, più precisamente del suo numero di frame. Può essere svolto ad ogni page fault, ossia quando un processo tra quelli attivi richiede una pagina non presente in memoria, o prima di avviare un nuovo processo.
# La lunghezza massima di un file che può essere memorizzato su un file system di tipo FAT viene calcolata moltiplicando il massimo numero di cluster (dimensione dell'unità di allocazione) identificabili per la loro dimensione. Il massimo numero di cluster identificabili dipende da quanti bit sono allocati per numerarli, e per questa distinzione esistono varie versioni di FAT (FAT12, FAT16, FAT32).
## FAT32 memorizza la dimensione dei file in un intero unsigned da 32bit, e non può quindi gestire un file di dimensione superiore ai 2^32 bit = ~4GB.
## FAT16, allocando 16bit per identificare i cluster, può contarne al massimo 2^16 (65536). Prendendo quindi, ad esempio, un file system FAT16 con cluster da 32KB, possiamo avere file grandi al massimo 32KB*65536 = ~2GB.
## FAT12 di conseguenza può numerare al massimo 2^12 (4096) cluster, ma dato che il numero dei settori del disco viene memorizzato in un intero signed a 16bit, la massima dimensione del disco è 2^15 = 32MB. Ovviamente, non si può memorizzare un file di grandezza superiore alla dimensione dell'unità di memorizzazione stessa, e quindi anche i file in FAT12 possono avere dimensione massima di 32MB.
# Entrambi condividono l'intento di infettare host con codice malevolo, ma differiscono fondamentalmente nella modalità: i virus infettano programmi già esistenti mediante un ''virus dropper'', mentre i worm diffondono copie di se stessi, solitamente attraverso la rete.
# In vari casi sulla base della natura del sistema. Innanzitutto, in sistemi batch ciò avviene se non sono stati inseriti più processi per un certo lasso di tempo. In sistemi general-purpose (es. per PC o dispositivi mobili) tale condizione è verificabile se tutti i processi sono in attesa su una coda che non è quella dello scheduler (ad. es. di un semaforo o di una periferica di I/O); casi concreti sono pertanto il deadlock (di tutti i processi del sistema) o attesa generale di I/O. Infine sempre in sistemi general-purpose tale condizione può manifestarsi, stavolta in condizioni patologiche, se ogni processo è assegnato ad una propria CPU/core, lasciando pertanto la coda d'attesa vuota.

= Esame 28/05/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.05.28.tot.pdf 2018.05.28.tot.pdf]
=== Esercizio c.1 ===
<syntaxhighlight lang="c">
Stack<int> entriesStack;

int vid[MAX];
condition ok2esci[MAX]
int in = 0;
int out = -1;

Procedure-entry: entra(int id) {
if (in >= MAX)
ok2entra.wait()
vid[in++] = id;
if (in < MAX)
ok2entra.signal()
else
out = MAX - 1;
}

Procedure-entry: esci(int id) {
int i;
for (i = 0; i < in; i++)
if (vid[i] == id)
break; //cerco l'indice di id nel vettore vid

if (i != out)
ok2esci[i].wait();

if (out > 0) {
out--;
ok2esci[out].signal();
} else {
out--;
in = 0;
ok2entra.signal();
}
}
</syntaxhighlight>
 

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">
Monitor riempisvuota {
Int MAXPROCESSI;
Stack s;
condition ok2enter;
condition ok2exit;

p.e void entra(getPid()){
if( s.size() >= MAXPROCESSI)
ok2enter.wait();
s.insert(getPid());
if(s.size() > MAXPROCESSI)
ok2exit.signal()
}

p.e void esci(getPid()){
if(s.size() > MAXPROCESSI && s.top == getPid()) {
s.pop();
ok2entra.signal()
}
else
ok2exit.wait();
}
</syntaxhighlight>
 
=== Esercizio c.2 (ERRATO) ===

* Soluzione proposta è errata, non puoi riceve in modo greedy e printare subito il carattere [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 11:33, 18 January 2023 (CET)

<syntaxhighlight lang="c">
proc[x]: x='a',...,'z'
while True:
//c sarà il carattere stampato dal processo precedente
(c, string) = arecv(*)
if(string == wait){
//mi metto in attesa di ricevere l'ACK da proc[x]
m=arecv(x);
}
if (c == NONE){
//significa che sei il primo a ricevere quella stringa
print(x);
if (len(string) > 1){
//mando la wait a tutti, il primo che riceve qualcosa da stampare manda una wait a tutti
asend(wait,*);
int l = len(string);
int i = 1;
while(l != 0){
asend(proc[string[i]], (x, string[i...]));
//si mette in attesa di ricevere l'ACK dal processo dell'ultima lettera della parola
m=areceive(proc[string[i]]);
//rimando la wait al processo per ribloccarlo
asend(wait, proc[string[i]])
l--;
i++;
}
//dopo aver finito la stampa della stringa sblocco tutti i processi
asend(ACK, *);
}
}else{
print(x);
asend(ACK, x);
//ricomincia il ciclo while, si rimette in attesa e il 'gestore gli rimanda la wait'
}
</syntaxhighlight>
 

=== Esercizio c.2 ===
[[User:Flecart|Flecart friend]] ([[User talk:Flecart|talk]]) cedo la proprità intellettuale di questa soluzione a flecart

<syntaxhighlight lang="c">
process [x]: x='a'..'z'
if(x=='a'){
asend(<NULL,NULL>,'b');
asend(<NULL,NULL>,'b');
}
While True:
<c,string>=arecv(x-1+26%26);
if(string==NULL):
<c,string>=arecv(*);
if(string!=NULL):
<c,string>=arecv(x-1+26%26);

if(string!=NULL):
if(string[0]==x):
print(string[0]);
if(string.len()>1):
aasend(<NULL,string[1:]>,(x+1)%26);
else:
aasend(<NULL,NULL>,(x+1)%26);
aasend(<NULL,NULL>,(x+1)%26);
else:
aasend(<NULL,string>,(x+1)%26);
else:
aasend(<NULL,NULL>,(x+1)%26);
aasend(<NULL,NULL>,(x+1)%26);

</syntaxhighlight>

=== Proposta c2 ===
* Proposto [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 11:31, 18 January 2023 (CET)

<syntaxhighlight lang="C">
proc[a]:
bool occupied = false;
queue<string> s;

while True {
(c, string) = arecv(*);

if (c == NONE) {
if (occupied) {
s.enqueue(string);
} else {
if (string.len() < 1)
continue;

occupied = true;
asend(string[0], (MIDDLE, string));
}
} else if (c == END) {
if (s.size() > 0) {
string ss = s.dequeue();
asend(string[0], (MIDLLE, string));
} else {
occupied = false;
}
} else {
print(x);
if (len(string) > 1)
asend(proc[string[0]], (MIDDLE, string[1:]));
else:
asend(proc[a], (END, ""));
}
}

proc[x]: x = 'b', ... 'z';
while True {
(c, string) = arecv(*);
if (c == NONE) {
asend(proc['a'], (NONE, string));
} else { // potrà essere solo MIDDLE
print(x);
if (len(string) > 1)
asend(proc[string[0]], (MIDDLE, string[1:]));
else:
asend(proc[a], (END, ""));
}
}
</syntaxhighlight>

= Esame 12/02/2018 =
[http://www.cs.unibo.it/~renzo/so/compiti/2018.02.12.tot.pdf 2018.02.12.tot.pdf]

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">

monitor bridge:

int ncar
bool boat_on_0
bool boat_on_1 // per semplicità, quando nel codice si trova boat_on_(direction) oppure isBoat(direction)(),
// si valuta il valore booleano di direction e lo si applica sotto forma di stringa al simbolo
// ad esso adiacente
bool is_raised
queue waiting_mean // i valori possibili sono: boat0, boat1 oppure car
condition ok2go

entry car_enter(direction):
if is_raised || ncar == MAXCAR:
waiting_mean.enqueue(car)
ok2go.wait()
is_raised = false
++ncar

entry car_exit(direction):
--ncar
if (waiting_mean.top().isBoat() && ncar == 0) || waiting_mean.top().isCar(): // isBoat ritorna true se l'oggetto su cui
waiting_mean.dequeue() // è invocata è boat0 oppure boat1
ok2go.signal()

entry boat_enter(direction):
if !is_raised || boat_on_(direction):
waiting_mean.enqueue(boat)
ok2go.wait()
if waiting_mean.top().isBoat(!direction)():
waiting_mean.dequeue()
ok2go.signal()
is_raised = true
boat_on_(direction) = true

entry boat_exit(direction):
boat_on_(direction) = false
if !boat_on_(!direction):
waiting_mean.dequeue()
ok2go.signal()

</syntaxhighlight>

 

=== Esercizio c.1 ===
<syntaxhighlight lang="c">
monitor bridge {
int carsOnBridge = 0;
int shipping[2] = {0, 0}; //navi da entrambe le direzioni
int status = NONE; //UP DOWN NONE
int last2pass = 0; //ultimo che ha passato il ponte
int waitingC = 0; //coda delle macchine che aspettano
int waitingS[2] = {0,0}; //navi che stanno aspettando

condition ok2ship[2]
condition ok2drive

entry car_enter(int direction){
if(carsOnBridge >= MAX || status == UP || waitingS[0] + waitingS[1] > 0 ){
waitingC++;ok2drive.wait;waitingC--;}
status = DOWN;
carsOnBridge++
if (carsOnBridge < MAX)
ok2drive.signal(); //vanno tutte le MAX car che stanno aspettando
}
entry car_exit(int direction){
carsOnBridge--
if (waitingS[0] + waitingS[1] == 0)
ok2drive.signal();
if(carsOnBridge == 0){
ok2ship[0].signal(); ok2ship[1].signal();
}
if(carsOnBridge + waitingS[0] + waitingS[1] == 0)
status = NONE
}

entry ship_enter(int direction){
if (bridge = DOWN || shipping[direction] != 0 || waitingC > 0)
{
waitingS[i]++; ok2ship[i].wait(); waitingS[i]--;
}
isBridgeUp = false;
shipping[i] = 1;

entry ship_exit(int direction){
shipping[i] = 0;
if (waitingC == 0)
ok2ship[i].signal()
else if(shipping[1-i] == 0)
ok2drive.signal();
if(carsOnBridge + waitingS[0] + waitingS[1] == 0)
status = NONE
}
</syntaxhighlight>

=== Esercizio c.1 (da controllare) ===
<syntaxhighlight lang="c">
monitor bridge {

UP=0;
DOWN=1;
bridgeis = DOWN;

bool carAreExiting = false;

condition ok2drive;
condition ok2barca[2];

waitingCar = 0;
carOnBridge = 0;

boatWaiting[2] = {0,0};
boatIsPassing[2] = {false,false}

entry car_enter(direction) {

if (bridgeis == DOWN)
if(carOnBridge == MAXCAR)
waitingCar++;
ok2drive.wait();
waitingCar--;
else if (carAreExiting)
waitingCar++;
ok2drive.wait();
waitingCar--;
else
if (boatIsPassing[0] || boatIsPassing[1])
waitingCar++;
ok2drive.wait();
waitingCar--;
bridgeis = DOWN;

carOnBridge++;
carAreExiting = false;
if(carOnBridge < MAXCAR && !carAreExiting)
ok2drive.signal();

}

entry car_exit(direction) {

carOnBridge--;
carAreExiting = true;

if(carOnBridge == 0)
carAreExiting = false;
if(boatWaiting[0] > 0)
bridgeis = UP;
ok2barca[0].signal();
else if (boatWaiting[1] > 0)
bridgeis = UP;
ok2barca[1].signal();
else
ok2drive.signal();
}

entry boat_enter(direction) {

if (bridgeis == UP)
| if (boatIsPassing[direction] == true)
| | boatWaiting[direction]++;
| | ok2barca.wait();
| | boatWaiting[direction]--;
else
| if (carOnBridge > 0)
| | boatWaiting[direction]++;
| | ok2barca.wait();
| | boatWaiting[direction]--;
| | bridgeis = UP;

boatIsPassing[direction] = true;

if(boatIsPassing[1-direction] == false && boatWaiting[1-direction] > 0)
ok2barca[1-direction].signal();

}

entry boat_exit(direction) {

boatIsPassing[direction] = false;

if (boatIsPassing[1-direction] == false)
if (waitingCar > 0)
bridgeis = DOWN;
ok2drive.signal();
else
if (waitingCar == 0)
ok2barca[direction].signal();

}
</syntaxhighlight>

=== Esercizio c.1 (sbagliato) ===
<syntaxhighlight lang="c">
monitor bridge
condition ok2passCar;
condition ok2passBoat;
condition ok2up;
condition ok2down;
int carOnBridge[2] = 0; //2 sensi di marcia
int boatUnderBridge[2] = 0;
boolean bridge_down = false; //vuol dire che il ponte parte alzato, true ponte abbassato

procedure entry car_enter(direction){
if(bridge_down && carOnBridge[direction] < MAXCAR){
carOnBridge[direction]++;
ok2passCar.signal();
}else if (bridge_down && boatUnderBridge[0] == 0 && boatUnderBridge[1] == 0){
//se non ci sono navi in transito e arriva una macchina abbassa ponte
ok2down.signal();
ok2passCar.signal();
ok2passBoat.wait();
}else{
ok2passCar.wait();
}
}

procedure entry car_exit(direction){
carOnBridge[direction]--;
if(carOnBridge[0] == 0 && carOnBridge[1] == 0){
bridge_down = false;
ok2up.signal();
}else{
ok2up.wait();
}
}

procedure entry boat_enter(direction){
if(!bridge_down && boatUnderBridge[direction] < 1){
boatUnderBridge[direction]++;
ok2passBoat.signal();
}else if(!bridge_down && carOnBridge[0] == 0 && carOnBridge[1] == 0){
ok2up.signal();
ok2passBoat.signal();
ok2passCar.wait();
}else {
ok2passBoat.wait();
}
}

procedure entry boat_exit(direction){
boatUnderBridge[direction]--;
if(boatUnderBridge[0] == 0 && boatUnderBridge[1] == 0){
bridge_down = true;
ok2down.signal();
}else{
ok2down.wait();
}
}
</syntaxhighlight>

=== Esercizio c.1 2o (sbagliato) ===
<syntaxhighlight lang="c">
#define car 1
#define ship 2
#define fromDX 1
#define fromSX 0

monitor bridge {
int carsOnBridge = 0;
int shippingDX = 0; //nave che sta passando dal lato destro
int shippingSX = 0; //nave che sta passando dal lato sinistro
bool isBridgeUp = false;
int last2pass = 0; //ultimo che ha passato il ponte
int waitingS = 0; //navi che stanno aspettando
int waitingC = 0 ; //auto che stanno aspettando

condition ok2ship
condition ok2drive

entry car_enter(int direction){
//un auto si ferma se il numero di auto sul ponte è massimo
//e se l'ultima a passare è stata un auto mentre ci sono navi in attesa
if(carsOnBridge == MAX || isBridgeUp || (last2pass==car && waitingS > 0) ){
waitingC++;
ok2drive.wait;
}
carsOnBridge++;
waitingC--;
}

entry car_exit(int direction){
carsOnBridge--;
last2pass = car;
if(carsOnBridge == 0 && waitingS>0){
isBrigdeUp = true;
ok2ship.signal;
}
}

entry ship_enter(int direction){
//se la barca viene da destra
if(direction == fromDX){
//si ferma anche quando c'è una nave che sta già attraversando nella sua stessa direzione
if (isBridgeup == false || shippingDX || (last2pass==ship && waitingC > 0) ){
waitingS++;
ok2ship.wait;
}
if (waitingS > 0)
waitingS--;
shippingDX = 1;
}
//se la barca viene da sinistra
else if(direction == fromSX){
if (isBridgeup == false || shippingSX || ( (last2pass==ship && waitingC > 0))){
waitingS++;
ok2ship.wait;
}
if (waitingS > 0)
waitingS--;
shippingSX = 1;

}
}

entry ship_exit(int direction){
if(direction == fromDX)
shippingDX = 0;
else if (direction == fromSX)
shippingSX = 0;
last2pass = ship;
if(shippingDX == 0 && shippingSX == 0 && waitingC)
isBrigdeUp == false;
ok2drive.signal;
else if(shippingDX == 0 && shippingSX == 0 && waitingS > 0)
ok2ship.signal;
}
}
</syntaxhighlight>

=== Esercizio c.2 (sbagliato) ===

# (Ri)Controllato dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]) in data 26/08/2020

<syntaxhighlight lang="python">
list printed_msg; # questa è una variabile condivisa che ai fini dell'esercizio non si può utilizzare (message passing)

process server[i]:
while true:
<msg, pid> = arecv(*)

if printed_msg.length == 0 or <msg, pid> is not in printed_msg:
printed_msg.append(<msg,id>)
print(msg)
</syntaxhighlight>

=== Esercizio c.2 (da controllare) ===
Nello svolgimento seguente, receiver incapsula l'ambiente privato del processo; _peers rappresenta il vettore di processi "fratelli" ai quali può essere chiesto di stampare un messaggio, mentre _printed contiene l'hash di tutti i messaggi stampati dal processo locale. Si suppone che istanze della classe receiver possano essere passate come parametro ad areceive() ed asend() (non implementate).

<syntaxhighlight lang="python">
class receiver:
def __init__(self, peers):
"""
:param peers: list of processes this process communicates with.
"""
self._peers = tuple(peers)
self._printed = list()

def run(self):
while True:
process, message = areceive(ANY)

if process in self._peers:
self._reply_query(process, message)
else:
self._print(process, message)

def _print(self, sender, message):
h = hash(message.text)

if h not in self._printed and not self._printed_from_peers(message):
self._printed.append(h)
print(message.text)

def _reply_query(self, sender, h):
"""
Invoked when the current process receive a "query" from a peer process.
`h` contains the hash of a message which may or may have not been
sent from this process; if it was sent, the reply is `Yes`, otherwise `No`.
"""
reply = "Yes" if int(h) in self._printed else "No"
asend(sender, reply)

def _printed_from_peers(self, message):
"""
:return: `True` if this message has already been printed from any of the
peer processes, `False` otherwise.
"""
h = hash(message)

for p in self._peers:
asend(p, str(h))

for p in self._peers:
_, reply = areceive(p)

if reply.text == "Yes":
return True
else if reply.text != "No":
# If the response is neither "Yes" nor "No", then we have got a query
self._reply_query(p, reply)

return False
</syntaxhighlight>

=== Esercizio g.1 (da controllare) ===
Sulla base dei valori in entrata, è possibile costruire le matrici Allocation (q.tà di risorse allocate per processo e per tipo), Need (q.tà di risorse che ogni processo potrebbe ancora chiedere) e il vettore Available (num. di risorse correntemente disponibili).

{| class="wikitable" style="float: left"
! colspan=3 | Allocation
|-
! !! A !! B
|-
| p1 || 4 || 5
|-
| p2 || 3 || 3
|-
| p3 || 2 || 4
|}

{| class="wikitable" style="float: left; margin-left: 1em"
! colspan=3 | Need
|-
! !! A !! B
|-
| p1 || 6 || 8
|-
| p2 || 6 || 3
|-
| p3 || 6 || 8
|}

{| class="wikitable" style="float: left; margin-left: 1em"
! colspan=2 | Available
|-
! A !! B
|-
| x || y
|}

 

Nel caso delle risorse di tipo A, deve aversi x >= 6 in quanto un processo dovrà essere selezionato come primo nella permutazione dell'algoritmo del banchiere multivaluta, e tutti quelli correnti hanno lo stesso valore Need(i)(1); per ciò che riguarda le risorse di tipo B, possiamo ragionare per esaustione

* Se il primo processo della permutazione è p1, allora y >= 8 (con questo valore posso soddisfare la richiesta di p1 e in seguito tutte le altre)
* Se il primo processo della permutazione è p2, allora y >= 5: con questo valore è possibile soddisfare la richiesta di p2; una volta che esso avrà finito, restituirà 3 unità della risorsa B, che permetteranno di soddisfare sia le richieste di A sia quelle di C
* Se il primo processo della permutazione è p3, allora y >= 8 (ragionamento analogo come per p1)

Volendo scegliere il minimo, y >= 5, ed in conclusione (x, y) >= (6, 5).

''Svolgimento basato in parte sull'approccio di Operating System Concepts di Silberschatz. et al, 9th edition, cap. 7.''

=== Esercizio g.2 (da controllare) ===
# Può accadere che il sistema torni in uno stato di safety o che invece porti a deadlock. Diversamente uno stato di safety non può portare direttamente ad uno stato di deadlock, ma solo ad uno di non-safety.
# Selezionare uno o più tra i processi attivi e sospenderli, salvando il loro stato su memoria secondaria operando delle operazioni di swap-out, finché l'insieme dei frame nella memoria centrale non è in grado di soddisfare tutti i processi rimasti attivi.
# La scelta è determinata perlopiù dal fattore costo. Con un sistema RAID 1 è possibile ripristinare un disco guasto molto brevemente, in quanto le operazioni coinvolte prevedono una semplice ricopiatura dal disco di backup; con un sistema RAID 5 il ripristino del disco guasto deve coinvolgere tutti i dischi dell'intero array, e ciò può richiedere anche ore per dischi di grandi dimensioni. D'altra parte RAID 1 è più costoso (con n dischi, posso memorizzare tanta informazione quanto potrei con n / 2 dischi) rispetto a RAID 5 dove, tra gli n dischi, complessivamente soltanto uno è destinato alle informazioni di ridondanza.
# ''Completare.''

Esercizi di "lettura" programmi in Python

2023-03-10T13:20:28Z

LiberaL: /* aggiunto pinyin senza toni alla numerazione */

Gli esercizi proposti sono programmi funzionanti.

Come svolgimento dell'esercizio si deve:
* determinare lo scopo del programma
* modificare, migliorare discutere le soluzioni proposta. Proporre soluzioni alternative dello stesso problema.

==1==
<source lang=python>
def dd(s):
d,m,y = s.split('.')
d,m,y = int(d),int(m),int(y)
md = [0,31,28,31,30,31,30,31,31,30,31,30,31]
if y % 4 == 0:
md[2]=29
dy = d
for i in range(1,m):
dy += md[i]
return dy

if __name__ == "__main__":
data=input("Dammi una data (es. 14.03.2014): ")
print("il risultato della funzione misteriosa e' ", dd(data))
</source>

==2==
<source lang=python>
def imin(l):
im,mn = 0,l[0]
for i in range(1,len(l)):
if l[i]<mn:
im,mn = i,l[i]
return im

if __name__ == "__main__":
l = input('dammi in input una lista di elementi (es: [1,2,3]): ')
print("l'output della funzione misteriosa e': ", imin(l))
</source>

==3==
<source lang=python>
def r13(s):
e = ''
for c in s:
if 'A' <= c <= 'Z':
e += chr(((ord(c)-ord('A')) + 13)%26 + ord('A'))
elif 'a' <= c <= 'z':
e += chr(((ord(c)-ord('a')) + 13)%26 + ord('a'))
else:
e += c
return e

if __name__ == "__main__":
s = input("scrivi una semplice frase (es: 'Ciao Mondo') ")
r = r13(s)
print("il risultato della funzione misteriosa e': ", r)
print("consiglio: prova a eseguire nuovamente il programma scrivendo")
print("la frase: ", r)
</source>

==4==
<source lang=python>
def pf(n):
f = []
for i in range(2,n+1):
while n % i == 0:
f.append(i)
n //= i
if n == 1:
break
return f

if __name__ == "__main__":
n = int(input("dammi un numero (consigliato da 2 a 1000): "))
print("il risultato della funzione misteriosa e' ", pf(n))
</source>

==5==
(richiede il modulo turtle)

<source lang=python>
import turtle
import random

def cy(r):
turtle.setup(400,400)
turtle.penup()
turtle.hideturtle()
turtle.speed(0)
for i in range(1000):
x,y = random.randint(-200,200),random.randint(-200,200)
if (x*x + y*y)**0.5 < r:
color = "red"
else:
color = "blue"
turtle.goto(x,y)
turtle.dot(5,color)

if __name__ == "__main__":
r = float(input("scrivi un numero (consigliato da 100 a 200): "))
print("guarda il risultato della funzione misteriosa")
cy(r)
turtle.exitonclick()
</source>

==6==
(richiede il modulo turtle)

<source lang=python>
import turtle

def poly(n):
for i in range(n):
turtle.forward(50)
turtle.left(360/n)

if __name__=="__main__":
n=int(input("dammi un intero (consigliato da 3 a 12): "))
poly(n)
turtle.exitonclick()
</source>

==7==
Questo e' contorto. Se vi piace... iniziate a preoccuparvi: state diventando informatici ;-)
<source lang=python>
f="f={0}{1}{0};print(f.format(chr(34),f))";print(f.format(chr(34),f))
</source>
NB: non e' necessario capire questo programma, e' solo per chi si vuole cimentare in una sfida...

==8==
<source lang=python>
def pf(n):
f=[]
for i in range(2,n+1):
while n % i == 0:
f.append(i)
n //= i
if n == 1:
break
return f

def fgcd(a,b):
def rgcd(fa,fb):
if fa and fb:
if fa[0]==fb[0]:
return fa[:1]+rgcd(fa[1:],fb[1:])
elif fa[0]<fb[0]:
return rgcd(fa[1:],fb)
else:
return rgcd(fa,fb[1:])
else:
return []
return rgcd(pf(a),pf(b))

def flcm(a,b):
def rlcm(fa,fb):
if fa and fb:
if fa[0]==fb[0]:
return fa[:1]+rlcm(fa[1:],fb[1:])
elif fa[0]<fb[0]:
return fa[:1]+rlcm(fa[1:],fb)
else:
return fa[:1]+rlcm(fa,fb[1:])
else:
return fa if fa else fb
return rlcm(pf(a),pf(b))

def mul(l):
rv=1
for el in l:
rv *= el
return rv

def gcd(x,y):
return mul(fgcd(x,y))

def lcm(x,y):
return mul(flcm(x,y))

if __name__=="__main__":
a,b=input("Inserisci due numeri (es: 48 36): ").split()
a,b=int(a),int(b)
print("pf({})={}".format(a,pf(a)))
print("pf({})={}".format(b,pf(b)))
print("fgcd({},{})={}".format(a,b,fgcd(a,b)))
print("flcm({},{})={}".format(a,b,flcm(a,b)))
print("gcd({},{})={}".format(a,b,gcd(a,b)))
print("lcm({},{})={}".format(a,b,lcm(a,b)))
</source>

==9==
<source lang=python>
def div(n):
return {x for x in range(1,n+1) if n % x == 0}

#alternativa:
#def div(n):
# d=set()
# for x in range(1,n+1):
# if n % x == 0: d.add(x)
# return d

def gcd(a,b):
return max(div(a) & div(b))

def mul(n,limit):
return {x*n for x in range(1,limit//n + 1)}

#alternativa
#def mul(n,limit):
# d=set()
# for x in range(1,limit//n + 1):
# d.add(x*n)
# return d

def lcm(a,b):
return min(mul(a,a*b) & mul(b,a*b))

if __name__=="__main__":
a,b=input("Inserisci due numeri (es: 48 36): ").split()
a,b=int(a),int(b)
print("div({})={}".format(a,div(a)))
print("div({})={}".format(b,div(b)))
print("mul({},{})={}".format(a,a*b,mul(a,a*b)))
print("mul({},{})={}".format(b,a*b,mul(b,a*b)))
print("gcd({},{})={}".format(a,b,gcd(a,b)))
print("lcm({},{})={}".format(a,b,lcm(a,b)))
</source>

==10==
<source lang=python>
def sdiv(n):
return {x for x in range(2,n) if n % x == 0}

#alternativa:
#def sdiv(n):
# d=set()
# for x in range(2,n):
# if n % x == 0: d.add(x)
# return d

def pr(n):
return not sdiv(n)

def pdiv(n):
return {x for x in sdiv(n) if pr(x)}

#alternativa:
#def pdiv(n):
# d=set()
# for x in sdiv(n):
# if pr(x): d.add(x)
# return d

def gcd(a,b):
csdiv=pdiv(a) & pdiv(b)
r=1
for x in csdiv:
while a % (r*x) == 0 and b % (r*x) == 0:
r *= x
return r

def lcm(a,b):
return a * b // gcd(a,b)

if __name__=="__main__":
a,b=input("Inserisci due numeri (es: 48 36): ").split()
a,b=int(a),int(b)
print("pdiv({})={}".format(a,pdiv(a)))
print("pdiv({})={}".format(b,pdiv(b)))
print("gcd({},{})={}".format(a,b,gcd(a,b)))
print("lcm({},{})={}".format(a,b,lcm(a,b)))
</source>
==11==
<source lang=python>
def tartline(l):
l[:0]=[1]
for i in range(1,len(l)-1):
l[i] += l[i+1]

l=[]
for i in range(12):
tartline(l)
print("{:^60}".format(str(l)))
</source>

==12==
<source lang=python>
def sdiv(n):
return {x for x in range(2,n) if n % x == 0}

#alternativa:
#def sdiv(n):
# d=set()
# for x in range(2,n):
# if n % x == 0: d.add(x)
# return d

def pr(n):
return not sdiv(n)

N=int(input("dammi il numero massimo (es 100): "))
print("ecco i numeri ***** fino a",N,":",[n for n in range(1,N+1) if pr(n)])
</source>

==13==
<source lang=python>
vf=[("Nella vecchia fattoria","Quante bestie ha zio Tobia","C'e' la capra","capra","ca"),
("Attaccato a un carrettino","C'è un quadrupede piccino","L'asinel","nel","nè"),
("Tra le casse e i ferri rotti", "Dove i topi son grassotti","C'è un bel gatto","gatto","ga"),
("Tanto grasso e tanto grosso", "Sempre sporco a più non posso", "C'è il maiale","iale","ia"),
("Poi sull'argine del fosso", "Alle prese con un osso", "C'è un bel cane","cane","ca"),
("Nella stalla silenziosa", "Dopo aver mangiato a iosa", "Dorme il bue","bue","bu")]
refrain="ia ia o"

def recverse(m,n):
v1,v2,an1,an2,an3=vf[m]
if n==m:
print(v1,refrain)
print(v2,refrain)
else:
recverse(m+1,n)
print(an1,an2,an3,an3,an2)

for i in range(len(vf)):
recverse(0,i)
print(vf[0][0],refrain)
print()
</source>

==14==
<source lang=python>
import turtle

def hser(size, level):
if level==0:
turtle.forward(size)
else:
hser(size,level-1)
turtle.left(45)
turtle.forward(size * 2**0.5)
turtle.left(45)
hser(size,level-1)
turtle.right(90)
turtle.forward(size)
turtle.right(90)
hser(size,level-1)
turtle.left(45)
turtle.forward(size * 2**0.5)
turtle.left(45)
hser(size,level-1)

def ser(size, level):
turtle.penup()
pos=(2**(level+2)-3) * size // 2 #posizione iniziale
turtle.setpos(-pos,pos)
turtle.pendown()
hser(size,level)
turtle.right(90)
hser(size,level)
turtle.right(90)
hser(size,level)
turtle.right(90)
hser(size,level)
turtle.right(90)

turtle.speed(0)
turtle.hideturtle()
ser(2,1)
ser(2,2)
ser(2,3)
ser(2,4)
turtle.exitonclick()
</source>
==15==
<source lang=python>
import turtle
import colorsys
import sys

def arrowstep(level, length, angle):
if level:
arrowstep(level-1, length/2, -angle)
turtle.left(angle)
arrowstep(level-1, length/2, angle)
turtle.left(angle)
arrowstep(level-1, length/2, -angle)
else:
turtle.forward(length)

def arrow(level, length):
if level & 1:
turtle.left(60)
arrowstep(level, length, -60)
else:
arrowstep(level, length, -60)

turtle.speed(0)
turtle.hideturtle()
turtle.colormode(1)
nmax=6
width=256
xmin= -width//2
ymin= -width*(3**0.5)//4
for n in range(nmax):
turtle.penup()
turtle.setposition(xmin,ymin)
turtle.setheading(0)
turtle.pencolor(colorsys.hls_to_rgb(1.0*n/6,0.5,1))
turtle.pendown()
arrow(n,256)

turtle.exitonclick()
</source>
==16==
<source lang=python>
def av(l):
return sum(l)/len(l)

def rg(l):
return max(l)-min(l)

def md(l):
lx=len(l)
ls=sorted(l)
if lx%2:
return ls[lx//2]
else:
return (ls[lx//2-1]+ls[lx//2])/2

if __name__=="__main__":
l=input("dammi una lista di numeri separati da virgole (es: 1,2,3,4.4): ")
l=[float(x) for x in l.split(',')]
print("i valori trovati dalle tre funzioni sono: {:.4f} {:.4f} {:.4f}".format(av(l),rg(l),md(l)))
</source>

==17==
<source lang=python>
import turtle
import sys

rows,cols=4,4
buttonsize=50
topdisplay=2*buttonsize

stack=[0]
fresh=True

def num(x):
global fresh,stack
if fresh:
stack[:0]=[x]
fresh=False
else:
stack[0]=stack[0]*10+x

enter,add,sub,mul,div=0,int.__add__,int.__sub__,int.__mul__,int.__floordiv__

def op(x):
global fresh,stack
if x!=enter and len(stack)>1:
stack=[x(stack[1],stack[0])]+stack[2:]
fresh=True

def off(x):
sys.exit(0)

buttons={
(0,0):('0',num,0), (1,0):('1',num,1), (1,1):('2',num,2), (1,2):('3',num,3), (2,0):('4',num,4),
(2,1):('5',num,5), (2,2):('6',num,6), (3,0):('7',num,7), (3,1):('8',num,8), (3,2):('9',num,9),
(3,3):('+',op,add), (2,3):('-',op,sub), (1,3):('*',op,mul), (0,3):('/',op,div),
(0,2):('ent',op,enter), (0,1):('off',off,0)}

def click(x,y):
col=x//buttonsize
row=y//buttonsize
if (row,col) in buttons:
label,op,val=buttons[row,col]
op(val)
drawcalc()

def drawcalc():
def drawbutton(col,row,label):
turtle.setpos(row*buttonsize,col*buttonsize)
turtle.pendown()
for _ in range(4):
turtle.forward(buttonsize)
turtle.left(90)
turtle.penup()
turtle.setpos(row*buttonsize+buttonsize//2,col*buttonsize+buttonsize//2)
turtle.write(label,align="center")
turtle.clear()
turtle.penup()
for row,col in buttons:
drawbutton(row,col,buttons[row,col][0])
turtle.setpos(row*buttonsize*(rows-1),col*buttonsize*(cols+1))
turtle.write(str(stack[0]),align="right")
turtle.update()

turtle.screensize(cols*buttonsize+1, rows*buttonsize+topdisplay+1)
turtle.setup(cols*buttonsize+1, rows*buttonsize+topdisplay+1)
turtle.setworldcoordinates(0,0,cols*buttonsize, rows*buttonsize+topdisplay)
turtle.hideturtle()
turtle.speed(10)
turtle.tracer(0)
drawcalc()
turtle.onscreenclick(click)
turtle.listen()
turtle.mainloop()
</source>

==18==
<source lang=python>
import turtle
import colorsys
import time

N=6
frompin=list(range(N,0,-1))
auxpin=[]
topin=[]

def rectangle(size, level, pin):
turtle.penup()
turtle.setpos(2*N*10*pin,level*10)
turtle.setheading(0)
turtle.pendown()
turtle.fillcolor(colorsys.hls_to_rgb(1.0*(size-1)/N,0.5,1))
turtle.begin_fill()
turtle.forward(size*10)
turtle.left(90)
turtle.forward(10)
turtle.left(90)
turtle.forward(size*20)
turtle.left(90)
turtle.forward(10)
turtle.left(90)
turtle.forward(size*10)
turtle.end_fill()

def showhanoi():
turtle.clear()
lf,la,lt=map(len,(frompin,auxpin,topin))
for i in range(lf):
rectangle(frompin[i], i, -1)
for i in range(la):
rectangle(auxpin[i], i, 0)
for i in range(lt):
rectangle(topin[i], i, 1)
turtle.update()
time.sleep(0.2)

def hanoi(n,f,a,t):
if n==1:
t.append(f.pop())
showhanoi()
else:
hanoi(n-1,f,t,a)
hanoi(1,f,a,t)
hanoi(n-1,a,f,t)

turtle.hideturtle()
turtle.speed(10)
turtle.tracer(0)
showhanoi()
hanoi(N,frompin,auxpin,topin)
turtle.exitonclick()
</source>
==19==
<source lang=python>
#!/usr/bin/env python3
# Copyright 2014 Renzo Davoli University of Bologna - Italy
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
#
import sys

class num:
def __init__(self,n):
self.val=n

class mul(num):
pass

class onemul(mul):
pass

class plus():
pass

class times():
pass

class numlanguage():
def __init__(self):
self.dict={}
def __setitem__(self,s,op):
self.dict[s]=op
for l in range(len(s)-1,0,-1):
if s[:l] in self.dict:
break
else:
self.dict[s[:l]]=None
return op
def match(self,s):
matchlen,obj=0,None
for l in range(1,len(s)+1):
if s[:l] in self.dict:
matchlen,obj=l,self.dict[s[:l]]
else:
break
return matchlen,obj

def str2num(langnum,s):
hi=mid=lo=last=0
lastop=None
while s:
if s[0] in " -\t\n":
s=s[1:]
else:
ml,obj=langnum.match(s)
if obj:
if isinstance(obj,num):
if isinstance(obj,mul):
if isinstance(obj,onemul) and lo == 0:
lo = 1
if (last <= obj.val or isinstance(lastop,times)) and not isinstance(lastop,plus):
hi,mid,lo = (hi+mid+lo)*obj.val,0,0
else:
hi,mid,lo = hi+(lo+mid)*obj.val,0,0
last=obj.val
else:
if obj.val == 100:
mid,lo = lo*obj.val if lo else obj.val,0
elif obj.val <= lo or isinstance(lastop,plus):
lo += obj.val
else:
lo = lo*obj.val if lo else obj.val
lastop=None
else:
lastop=obj
#print(s[:ml],hi,mid,lo,last,lastop)
s=s[ml:]
else:
return -1
return hi+mid+lo

def num_it():
nl=numlanguage()
nl["zero"]=num(0)
nl["uno"]=nl["un"]=nl["una"]=num(1)
nl["due"]=num(2)
nl["tre"]=num(3)
nl["quattro"]=num(4)
nl["cinque"]=num(5)
nl["sei"]=num(6)
nl["sette"]=num(7)
nl["otto"]=num(8)
nl["nove"]=num(9)
nl["dieci"]=num(10)
nl["undici"]=num(11)
nl["dodici"]=num(12)
nl["tredici"]=num(13)
nl["quattordici"]=num(14)
nl["quindici"]=num(15)
nl["sedici"]=num(16)
nl["diciassette"]=num(17)
nl["diciotto"]=num(18)
nl["diciannove"]=num(19)
nl["venti"]=nl["vent"]=num(20)
nl["trenta"]=nl["trent"]=num(30)
nl["quaranta"]=nl["quarant"]=num(40)
nl["cinquanta"]=nl["cinquant"]=num(50)
nl["sessanta"]=nl["sessant"]=num(60)
nl["settanta"]=nl["settant"]=num(70)
nl["ottanta"]=nl["ottant"]=num(80)
nl["novanta"]=nl["novant"]=num(90)
nl["cento"]=num(100)
nl["mille"]=onemul(10**3)
nl["mila"]=nl["migliaia"]=mul(10**3)
nl["milioni"]=nl["milione"]=mul(10**6)
nl["miliardi"]=nl["miliardo"]=mul(10**9)
nl["dozzine"]=nl["dozzina"]=mul(12)
nl["decine"]=mul(10)
nl["centinaia"]=mul(100)
nl["di"]=times()
nl["e"]=plus()
return nl

def num_en():
nl=numlanguage()
nl["zero"]=nl["null"]=num(0)
nl["one"]=nl["a"]=num(1)
nl["two"]=num(2)
nl["three"]=num(3)
nl["four"]=num(4)
nl["five"]=num(5)
nl["six"]=num(6)
nl["seven"]=num(7)
nl["eight"]=num(8)
nl["nine"]=num(9)
nl["ten"]=num(10)
nl["eleven"]=num(11)
nl["twelve"]=num(12)
nl["thirteen"]=num(13)
nl["fourteen"]=num(14)
nl["fifteen"]=num(15)
nl["sixteen"]=num(16)
nl["seventeen"]=num(17)
nl["eighteen"]=num(18)
nl["nineteen"]=num(19)
nl["twenty"]=num(20)
nl["thirty"]=num(30)
nl["forty"]=num(40)
nl["fifty"]=num(50)
nl["sixty"]=num(60)
nl["seventy"]=num(70)
nl["eighty"]=num(80)
nl["ninety"]=num(90)
nl["hundred"]=num(100)
nl["thousand"]=mul(10**3)
nl["million"]=mul(10**6)
nl["billion"]=mul(10**9)
nl["trillion"]=mul(10**12)
nl["dozen"]=mul(12)
nl["and"]=plus()
nl["of"]=times()
return nl

def num_fr():
nl=numlanguage()
nl["zero"]=num(0)
nl["un"]=num(1)
nl["deux"]=num(2)
nl["trois"]=num(3)
nl["quatre"]=num(4)
nl["cinq"]=num(5)
nl["six"]=num(6)
nl["sept"]=num(7)
nl["huit"]=num(8)
nl["neuf"]=num(9)
nl["dix"]=num(10)
nl["onze"]=num(11)
nl["douze"]=num(12)
nl["treize"]=num(13)
nl["quatorze"]=num(14)
nl["quinze"]=num(15)
nl["seize"]=num(16)
nl["vingt"]=num(20)
nl["trente"]=num(30)
nl["quarante"]=num(40)
nl["cinquante"]=num(50)
nl["soixante"]=num(60)
nl["cent"]=num(100)
nl["mille"]=onemul(10**3)
nl["million"]=mul(10**6)
nl["milliard"]=mul(10**9)
nl["douzaine"]=mul(12)
nl["et"]=plus()
nl["de"]=times()
return nl

def num_de():
nl=numlanguage()
nl["null"]=num(0)
nl["eins"]=nl["ein"]=num(1)
nl["zwei"]=nl["zwo"]=num(2)
nl["drei"]=num(3)
nl["vier"]=num(4)
nl["fÃ¼nf"]=num(5)
nl["sechs"]=num(6)
nl["sieben"]=num(7)
nl["acht"]=num(8)
nl["neun"]=num(9)
nl["zehn"]=num(10)
nl["elf"]=num(11)
nl["zwÃ¶lf"]=num(12)
nl["dreizehn"]=num(13)
nl["vierzehn"]=num(14)
nl["fÃ¼nfzehn"]=num(15)
nl["sechzehn"]=num(16)
nl["siebzehn"]=num(17)
nl["achtzehn"]=num(18)
nl["neunzehn"]=num(19)
nl["zwanzig"]=num(20)
nl["dreiÎ²ig"]=num(30)
nl["dreiÃig"]=num(30)
nl["vierzig"]=num(40)
nl["fÃ¼nfzig"]=num(50)
nl["sechzig"]=num(60)
nl["siebzig"]=num(70)
nl["achtzig"]=num(80)
nl["neunzig"]=num(90)
nl["hundert"]=num(100)
nl["tausend"]=mul(10**3)
nl["million"]=mul(10**6)
nl["milliard"]=mul(10**9)
nl["und"]=plus()
return nl

def num_ch():
nl=numlanguage()
'''pinyin senza toni purtroppo T_T'''
nl["ling"]=num(0)
nl["yi"]=num(1)
nl["er"]=nl["liang"]=num(2)
nl["san"]=num(3)
nl["si"]=num(4)
nl["wu"]=num(5)
nl["liu"]=num(6)
nl["qi"]=num(7)
nl["ba"]=num(8)
nl["jiu"]=num(9)
nl["sci"]=num(10)
nl["bai"]=num(100)
nl["qian"]=mul(10**3)
nl["wan"]=mul(10**4)
return nl

def num_es():
nl=numlanguage()
nl["cero"]=num(0)
nl["uno"]=num(1)
nl["dos"]=num(2)
nl["tres"]=num(3)
nl["cuatro"]=num(4)
nl["cinco"]=num(5)
nl["seis"]=num(6)
nl["siete"]=num(7)
nl["ocho"]=num(8)
nl["nueve"]=num(9)
nl["diez"]=num(10)
nl["once"]=num(11)
nl["doce"]=num(12)
nl["trece"]=num(13)
nl["catorce"]=num(14)
nl["quince"]=num(15)
nl["diecisÃ©is"]=num(16)
nl["diecisiete"]=num(17)
nl["dieciocho"]=num(18)
nl["diecinueve"]=num(19)
nl["veinte"]=nl["veinti"]=num(20)
nl["treinta"]=num(30)
nl["cuarenta"]=num(40)
nl["cincuenta"]=num(50)
nl["sesenta"]=num(60)
nl["setenta"]=num(70)
nl["ochenta"]=num(80)
nl["noventa"]=num(90)
nl["cien"]=nl["cientos"]=num(100)
nl["quinientos"]=num(500)
nl["setecientos "]=num(700)
nl["novecientos"]=num(900)
nl["mil"]=onemul(10**3)
nl["millÃ³n"]=nl["millones"]=mul(10**6)
nl["billÃ³n"]=nl["billones"]=mul(10**12)
nl["y"]=plus()
return nl

if __name__ == "__main__":
itnum=num_it()
print("it",str2num(itnum,sys.argv[1]))
ennum=num_en()
print("en",str2num(ennum,sys.argv[1]))
frnum=num_fr()
print("fr",str2num(frnum,sys.argv[1]))
denum=num_de()
print("de",str2num(denum,sys.argv[1]))
esnum=num_es()
print("es",str2num(esnum,sys.argv[1]))
chnum=num_ch()
print("ch",str2num(chnum,sys.argv[1]))
</source>
==20==
trace.py:
<source lang=python>
def trace(f):
f.indent = 0
def strtuple(x):
return "("+str(x[0])+")" if len(x)==1 else str(x)
def g(*x):
print('| ' * f.indent + '/-- ', f.__name__, strtuple(x), sep='')
f.indent += 1
value = f(*x)
f.indent -= 1
print('| ' * f.indent + '\-- ', 'return', repr(value))
return value
return g

def memoize(f):
cache = {}
def g(*x):
if x not in cache:
cache[x] = f(*x)
return cache[x]
return g
</source>
main.py:
<source lang=python>
#!/usr/bin/env python3
import sys
import trace

# try to uncomment the following statements:
#@trace.trace
#@trace.memoize
def fib(i):
if i<=0:
return 0
elif i==1:
return 1
else:
return fib(i-1)+fib(i-2)

if __name__=="__main__":
for i in range(int(sys.argv[1])):
print(i,fib(i))
</source>

20220906c2

2022-10-26T10:07:07Z

LiberaL: /* Correzioni proposte */

In questa pagina sono presenti alcune soluzioni (possibilmente con errore) per l'esercizio C2 dell'esame 2022/09/06.
Il lettore è invitato a immedesimare il professore al momento della correzione durante la lettura delle soluzioni.

== Consegna ==
Usando i semafori implementare un servizio che preveda due funzioni:
void sumstop(int v)
int sumgo(void)
La funzione sumstop deve mettere il processo chiamante in attesa.
La funzione sumgo deve sbloccare tutti i processi messi in attesa con la sumstop e restituire la somma algebrica dei valori passati come parametro alla sumstop dai processi che sono stati sbloccati (zero se la sumgo viene richiamata quando non c'è nessun processo bloccato).
== 1 ==
<pre>
semaphore sem(1);
int sum=0;
queue q;

void sumstop(int v):
if i < 0:
q.enqueue(v)
sem.P()
else
i--

int sumgo(void):
for each elem in q:
int val=q.dequeue()
sum=sum + val
return sum

</pre>
== 2 ==
<pre>
queue values;
semaphore s(0);
int sum=0;

void sumstop(int v):
s.P()
values.enqueue(v)

int sumgo(void):
while !value.isEmpty():
s.V()
mutex.P()
sum=sum+values.dequeue()
mutex.v()
return sum

</pre>
== 3 ==
<pre>
shared int sum=0;
semaphore wait(0);
semaphore mutex(1);

void sumstop(int v):
mutex.P();
sum = sum + v;
mutex.V();
wait.P();

int sumgo(void):
wait.V();
somma = sum;
mutex.P()
sum = 0
mutex.V()
return somma;

</pre>
== 4 ==
<pre>
queue<int> processlist;
semaphore mutex(1);
semaphore s(0);

void sumstop(int v):
mutex.P();
processlist.enqueue(v);
mutex.P(); // V non P
S.P();

int sumgo(void):
int sum = 0;
mutex.P();
while processlist.top() != NULL:
sum += processlist.dequeue();
S.V();
mutex.V()
return sum;

</pre>

== 5 ==
<pre>
int counter = 0;
int sum = 0;
semaphore mutex(1);
semaphore blocked(0);

void sumstop(int v):
mutex.P();
sum+=v;
counter++;
mutex.V();
blocked.P();

int sumgo(void):
mutex.P();
intret = sum;
sum = 0;
for (int i=0; i<counter; i++)
blocked.V()
counter = 0;
mutex.V()
return intret

</pre>

== 6 ==
<pre>
int sum = 0;
mutex = new semaphore(1);
queue q;

void sumstop(int v):
mutex.P();
sum += v;
sintpid = getpid();
suspend(pid);
mutex.V();

int sumgo(void):
mutex.P();
while !q.empty():
resume(q.dequeue())
int value = sum;
sum = 0;
return value;

</pre>
== 7 ==
<pre>
int nP, nV = -1, 0;
int somma = 0
int val[]
semaphore mutex(1);
semaphore s(0);

void sumstop(int v):
mutex.P()
val[nP++].add[v]
s.P()
np--
v[0].delete

int sumgo(void):
mutex.P();
nV++
if nP > 0:
s.V()
for (int i=0; i<nV; i++)
somma += val[i]
nv--
else
mutex.V()
return somma

</pre>
== 8 ==
<pre>
struct blocked {
semaphore sem(0);
int value = 0;
};

semaphore mutex(1);
list<blocked> procs = new list<blocked>();

void sumstop(int v):
mutex.P()
blocked bl = new blocked();
bl.value = v
procs.add(bl)
bl.sem.P()
mutex.V()

int sumgo(void):
mutex.P();
int count = 0;
foreach proc in procs:
count += proc.value
procs.remove(proc)
proc.sem.V()
mutex.V()
return count;

</pre>
== 9 ==
<pre>
semaphore s[] new sem(0)
semaphore s1 new sem(0)
int tot, waiting = 0;

void sumstop(int v):
waiting++
s[waiting - 1].P()
waiting--
tot = tot + v
if waiting == 0:
s1.V()

int sumgo(void):
if waiting = 0:
return 0
for (i = waiting -1; i == 0; i--)
s[i].V()
s1.P() // per aspettare che tutti abbiano fatto la somma
return tot

</pre>

== 10 ==
<pre>
int nw = 0
int currsum = 0
semaphore mutex(1)
semaphore wait2go(0)

void sumstop(int v):
mutex.P()
currsum += v;
nw++;
mutex.V()
wait2go.P()
if --nw > 0:
wait2go.V()
else
mutex.V()

int sumgo(void):
mutex.P();
if nw == 0:
mutex.V()
return 0;
int sum = cursum;
cursum = 0;
wait2go.V();
return sum

</pre>
== 11==
<pre>
semaphore mutex(1);
semaphore semwait(0);
int sum=0;
int wait=0;

void sumstop(int v):
mutex.P()
wait++
sum += v;
mutex.V()
semwait.P()
mutex.P()
wait--;
mutex.V()
if wait > 0:
semwait.V()

int sumgo(void):
if wait == 0:
return 0
semwait.V();
while (wait > 0) {}
int val = sum
mutex.P()
sum = 0;
mutex.V()
return val;

</pre>
== 12 ==
<pre>
semaphore mutex(0)
volatile int counter = 0

void sumstop(int v):
counter = counter + v;
mutex.P()

int sumgo(void):
int val = counter;
while (mutex.value != 0)
mutex.V()
counter = 0;
return counter

</pre>
== 13 ==
<pre>
semaphore mutex(1)
int sum = 0;
queue of semaphore q;

void sumstop(int v):
mutex.P()
sum += v;
s = new semaphore(0);
q.enqueue(s)
mutex.V()
s.P()
free(s)

int sumgo(void):
mutex.P()
int lsum = sum
sum = 0
while (!q.empty()):
semaphore s = q.dequeue()
s.V()
mutex.V()

</pre>
== 14 ==
<pre>
semaphore mutex(1)
int sum = 0;
queue of semaphore q;

void sumstop(int v):
mutex.P()
sum += v;
s = new semaphore(0);
q.enqueue(s)
mutex.V()
s.P()
free(s)
if(q.empty())
mutex.V()
else
semaphore s = q.dequeue()
s.V()

int sumgo(void):
mutex.P()
int lsum = sum
sum = 0
if(q.empty())
mutex.V()
else
semaphore s = q.dequeue()
s.V()

</pre>

== 15 (soluzione proposta su telegram) ==
<syntaxhighlight lang=C>
#include <pthread.h>
#include "semaphore.h"

semaphore s; // semaforo che blocca le somme
semaphore finished; // semaforo che indica che le somme sono state fatte
semaphore critical_section; // sarà utilizzata per decidere chi entra nella critical section

volatile int sumstops = 0;
volatile int result;

void *sumstop(int v) {
semaphore_P(critical_section);
sumstops++;
semaphore_V(critical_section);

semaphore_P(s);
printf("summed %d\n", v);
result += v;
semaphore_V(finished);
}

int sumgo(void) {
semaphore_P(critical_section); // così sumstops è costante all'interno di questa section
result = 0;
for (int i = 0; i < sumstops; i++) {
semaphore_V(s); // permetti alla somma di andare
semaphore_P(finished); // aspetta che la somma sia finita prima di continuare
}
sumstops = 0; // reset number of blocked stops.
semaphore_V(critical_section);
return result;
}

void *run_sumgo(void) {
int res = sumgo();
printf("the result found is %d\n", res);
printf("the result found is %d\n", result);
}

int main() {
srand(time(NULL));
s = semaphore_create(0);
critical_section = semaphore_create(1);
finished = semaphore_create(0);

int n = rand() % 50;
pthread_t sumg, s[n];

for (int i = 0; i < n; i++) {
pthread_create(&s[i], NULL, sumstop, i);
}
pthread_create(&sumg, NULL, run_sumgo, NULL);

for (int i = 0; i < 10; i++) {
pthread_join(s[i], NULL);
}

pthread_join(sumg, NULL);
}

</syntaxhighlight>

== Correzioni proposte ==

Correzione proposta da [https://t.me/flecarts flecart]
(e poi modificata successivamente da altri studenti ... tra cui: [https://t.me/LLibera LLibera] )

1. la variabile i non è inizializzata, sum e queue non sono protette in critical sections, inoltre la sem.V() non compare mai nel codice della sumgo.

2. la coda value non è in una critical section, può creare errori nell'update di essa, solo sum viene considerata da proteggere, ma devono essere protette entrambe. La enqueue avrebbe senso farla solo prima di bloccarsi nel semaforo, se viene fatta dopo al momento della chiamata di sumgo non ci sono valori all'interno della coda!

3. sumgo libera solamente un singolo sumstop, perché chiama wait.V() una singola volta anche se ci sono più thread in attesa

4. mutex.P() è chiamata due volte in sumstop(), se il secondo fosse mutex.V() credo sia corretto.

5. mi sembra corretto (ma l'indentazione è poco sensata).

6. non si possono utilizzare suspend o resume (non si è fatto uso di semafori, e l'implementazione deve essere fatta all'esterno del kernel non all'interno). Oltre a questo pid non è inizializzata e sintpid non è utilizzata. Se anche la suspend fosse una sem.P() e la resume una sem.V() non dovremmo sospendere il processo all'interno della mutua esclusione.

7. nP e nV mi sembrano superflue, in questo caso sicuramente scorrette perché se chiamo m volte sumstop e una volta sumgo, nV è al massimo 1
quindi è impossibile che riesca a contare correttamente tutte le somme.

8. Deadlock perché bl.sem.P() è chiamato prima che ls Critical Section venga rilasciata e sumgo ha bisogno di entrare in una CS.

9. waiting è una variabile globale modificata senza cs, e tot non è inizializzato.

10. simile a 3. wait2go è chiamata una volta quindi può liberare solamente un singolo thread di sumstop.

11. busy waiting in sumgo.

12. counter non è protetto da Critical section

13. se sumgo ritornasse il valore lsum sarebbe tutto apposto.

14. mi sembra corretto, manca solo la return in sumgo

15. mi sembra corretto

20220906c2

2022-10-20T07:47:07Z

LiberaL:

In questa pagina sono presenti alcune soluzioni (possibilmente con errore) per l'esercizio C2 dell'esame 2022/09/06.
Il lettore è invitato a immedesimare il professore al momento della correzione durante la lettura delle soluzioni.

== Consegna ==
Usando i semafori implementare un servizio che preveda due funzioni:
void sumstop(int v)
int sumgo(void)
La funzione sumstop deve mettere il processo chiamante in attesa.
La funzione sumgo deve sbloccare tutti i processi messi in attesa con la sumstop e restituire la somma algebrica dei valori passati come parametro alla sumstop dai processi che sono stati sbloccati (zero se la sumgo viene richiamata quando non c'è nessun processo bloccato).
== 1 ==
<pre>
semaphore sem(1);
int sum=0;
queue q;

void sumstop(int v):
if i < 0:
q.enqueue(v)
sem.P()
else
i--

int sumgo(void):
for each elem in q:
int val=q.dequeue()
sum=sum + val
return sum

</pre>
== 2 ==
<pre>
queue values;
semaphore s(0);
int sum=0;

void sumstop(int v):
s.P()
values.enqueue(v)

int sumgo(void):
while !value.isEmpty():
s.V()
mutex.P()
sum=sum+values.dequeue()
mutex.v()
return sum

</pre>
== 3 ==
<pre>
shared int sum=0;
semaphore wait(0);
semaphore mutex(1);

void sumstop(int v):
mutex.P();
sum = sum + v;
mutex.V();
wait.P();

int sumgo(void):
wait.V();
somma = sum;
mutex.P()
sum = 0
mutex.V()
return somma;

</pre>
== 4 ==
<pre>
queue<int> processlist;
semaphore mutex(1);
semaphore s(0);

void sumstop(int v):
mutex.P();
processlist.enqueue(v);
mutex.P();
S.P();

int sumgo(void):
int sum = 0;
mutex.P();
while processlist.top() != NULL:
sum += processlist.dequeue();
S.V();
mutex.V()
return sum;

</pre>
== 5 ==
<pre>
int counter = 0;
int sum = 0;
semaphore mutex(1);
semaphore blocked(0);

void sumstop(int v):
mutex.P();
sum+=v;
counter++;
mutex.V();
blocked.P();

int sumgo(void):
mutex.P();
intret = sum;
sum = 0;
for (int i=0; i<counter; i++)
blocked.V()
counter = 0;
mutex.V()
return intret

</pre>
== 6 ==
<pre>
int sum = 0;
mutex = new semaphore(1);
queue q;

void sumstop(int v):
mutex.P();
sum += v;
sintpid = getpid();
suspend(pid);
mutex.V();

int sumgo(void):
mutex.P();
while !q.empty():
resume(q.dequeue())
int value = sum;
sum = 0;
return value;

</pre>
== 7 ==
<pre>
int nP, nV = -1, 0;
int somma = 0
int val[]
semaphore mutex(1);
semaphore s(0);

void sumstop(int v):
mutex.P()
val[nP++].add[v]
s.P()
np--
v[0].delete

int sumgo(void):
mutex.P();
nV++
if nP > 0:
s.V()
for (int i=0; i<nV; i++)
somma += val[i]
nv--
else
mutex.V()
return somma

</pre>
== 8 ==
<pre>
struct blocked {
semaphore sem(0);
int value = 0;
};

semaphore mutex(1);
list<blocked> procs = new list<blocked>();

void sumstop(int v):
mutex.P()
blocked bl = new blocked();
bl.value = v
procs.add(bl)
bl.sem.P()
mutex.V()

int sumgo(void):
mutex.P();
int count = 0;
foreach proc in procs:
count += proc.value
procs.remove(proc)
proc.sem.V()
mutex.V()
return count;

</pre>
== 9 ==
<pre>
semaphore s[] new sem(0)
semaphore s1 new sem(0)
int tot, waiting = 0;

void sumstop(int v):
waiting++
s[waiting - 1].P()
waiting--
tot = tot + v
if waiting == 0:
s1.V()

int sumgo(void):
if waiting = 0:
return 0
for (i = waiting -1; i == 0; i--)
s[i].V()
s1.P() // per aspettare che tutti abbiano fatto la somma
return tot

</pre>

== 10 ==
<pre>
int nw = 0
int currsum = 0
semaphore mutex(1)
semaphore wait2go(0)

void sumstop(int v):
mutex.P()
currsum += v;
nw++;
mutex.V()
wait2go.P()
if --nw > 0:
wait2go.V()
else
mutex.V()

int sumgo(void):
mutex.P();
if nw == 0:
mutex.V()
return 0;
int sum = cursum;
cursum = 0;
wait2go.V();
return sum

</pre>
== 11==
<pre>
semaphore mutex(1);
semaphore semwait(0);
int sum=0;
int wait=0;

void sumstop(int v):
mutex.P()
wait++
sum += v;
mutex.V()
semwait.P()
mutex.P()
wait--;
mutex.V()
if wait > 0:
semwait.V()

int sumgo(void):
if wait == 0:
return 0
semwait.V();
while (wait > 0) {}
int val = sum
mutex.P()
sum = 0;
mutex.V()
return val;

</pre>
== 12 ==
<pre>
semaphore mutex(0)
volatile int counter = 0

void sumstop(int v):
counter = counter + v;
mutex.P()

int sumgo(void):
int val = counter;
while (mutex.value != 0)
mutex.V()
counter = 0;
return counter

</pre>
== 13 ==
<pre>
semaphore mutex(1)
int sum = 0;
queue of semaphore q;

void sumstop(int v):
mutex.P()
sum += v;
s = new semaphore(0);
q.enqueue(s)
mutex.V()
s.P()
free(s)

int sumgo(void):
mutex.P()
int lsum = sum
sum = 0
while (!q.empty()):
semaphore s = q.dequeue()
s.V()
mutex.V()

</pre>
== 14 ==
<pre>
semaphore mutex(1)
int sum = 0;
queue of semaphore q;

void sumstop(int v):
mutex.P()
sum += v;
s = new semaphore(0);
q.enqueue(s)
mutex.V()
s.P()
free(s)
if(q.empty())
mutex.V()
else
semaphore s = q.dequeue()
s.V()

int sumgo(void):
mutex.P()
int lsum = sum
sum = 0
if(q.empty())
mutex.V()
else
semaphore s = q.dequeue()
s.V()

</pre>

== 15 (soluzione proposta su telegram) ==
<syntaxhighlight lang=C>
#include <pthread.h>
#include "semaphore.h"

semaphore s; // semaforo che blocca le somme
semaphore finished; // semaforo che indica che le somme sono state fatte
semaphore critical_section; // sarà utilizzata per decidere chi entra nella critical section

volatile int sumstops = 0;
volatile int result;

void *sumstop(int v) {
semaphore_P(critical_section);
sumstops++;
semaphore_V(critical_section);

semaphore_P(s);
printf("summed %d\n", v);
result += v;
semaphore_V(finished);
}

int sumgo(void) {
semaphore_P(critical_section); // così sumstops è costante all'interno di questa section
result = 0;
for (int i = 0; i < sumstops; i++) {
semaphore_V(s); // permetti alla somma di andare
semaphore_P(finished); // aspetta che la somma sia finita prima di continuare
}
sumstops = 0; // reset number of blocked stops.
semaphore_V(critical_section);
return result;
}

void *run_sumgo(void) {
int res = sumgo();
printf("the result found is %d\n", res);
printf("the result found is %d\n", result);
}

int main() {
srand(time(NULL));
s = semaphore_create(0);
critical_section = semaphore_create(1);
finished = semaphore_create(0);

int n = rand() % 50;
pthread_t sumg, s[n];

for (int i = 0; i < n; i++) {
pthread_create(&s[i], NULL, sumstop, i);
}
pthread_create(&sumg, NULL, run_sumgo, NULL);

for (int i = 0; i < 10; i++) {
pthread_join(s[i], NULL);
}

pthread_join(sumg, NULL);
}

</syntaxhighlight>

== Correzioni proposte ==

Correzione proposta da [https://t.me/flecarts flecart]
(e poi modificata successivamente da altri studenti ... tra cui: [https://t.me/LLibera LLibera] )

1. la variabile i non è inizializzata, sum e queue non sono protette in critical sections, inoltre la sem.V() non compare mai nel codice della sumgo.

2. la coda value non è in una critical section, può creare errori nell'update di essa, solo sum viene considerata da proteggere, ma devono essere protette entrambe. La enqueue avrebbe senso farla solo prima di bloccarsi nel semaforo, se viene fatta dopo al momento della chiamata di sumgo non ci sono valori all'interno della coda!

3. sumgo libera solamente un singolo sumstop, perché chiama wait.V() una singola volta anche se ci sono più thread in attesa

4. mutex.P() è chiamata due volte in sumstop(), se il secondo fosse mutex.V() credo sia corretto.

5. mi sembra corretto (ma l'indentazione è poco sensata).

6. non si possono utilizzare suspend o resume (non si è fatto uso di semafori, e l'implementazione deve essere fatta all'esterno del kernel non all'interno). Oltre a questo pid non è inizializzata e sintpid non è utilizzata. Se anche la suspend fosse una sem.P() e la resume una sem.V() non dovremmo sospendere il processo all'interno della mutua esclusione.

7. nP e nV mi sembrano superflue, in questo caso sicuramente scorrette perché se chiamo m volte sumstop e una volta sumgo, nV è al massimo 1
quindi è impossibile che riesca a contare correttamente tutte le somme.

8. Deadlock perché bl.sem.P() è chiamato prima che ls Critical Section venga rilasciata e sumgo ha bisogno di entrare in una CS.

9. waiting è una variabile globale modificata senza cs, e tot non è inizializzato.

10. simile a 3. wait2go è chiamata una volta quindi può liberare solamente un singolo thread di sumstop.

11. busy waiting in sumgo.

12. counter non è protetto da Critical section

13. se sumgo ritornasse il valore lsum sarebbe tutto apposto.

14. mi sembra corretto

15. mi sembra corretto

20220906c2

2022-10-20T07:45:51Z

LiberaL:

In questa pagina sono presenti alcune soluzioni (possibilmente con errore) per l'esercizio C2 dell'esame 2022/09/06.
Il lettore è invitato a immedesimare il professore al momento della correzione durante la lettura delle soluzioni.

== Consegna ==
Usando i semafori implementare un servizio che preveda due funzioni:
void sumstop(int v)
int sumgo(void)
La funzione sumstop deve mettere il processo chiamante in attesa.
La funzione sumgo deve sbloccare tutti i processi messi in attesa con la sumstop e restituire la somma algebrica dei valori passati come parametro alla sumstop dai processi che sono stati sbloccati (zero se la sumgo viene richiamata quando non c'è nessun processo bloccato).
== 1 ==
<pre>
semaphore sem(1);
int sum=0;
queue q;

void sumstop(int v):
if i < 0:
q.enqueue(v)
sem.P()
else
i--

int sumgo(void):
for each elem in q:
int val=q.dequeue()
sum=sum + val
return sum

</pre>
== 2 ==
<pre>
queue values;
semaphore s(0);
int sum=0;

void sumstop(int v):
s.P()
values.enqueue(v)

int sumgo(void):
while !value.isEmpty():
s.V()
mutex.P()
sum=sum+values.dequeue()
mutex.v()
return sum

</pre>
== 3 ==
<pre>
shared int sum=0;
semaphore wait(0);
semaphore mutex(1);

void sumstop(int v):
mutex.P();
sum = sum + v;
mutex.V();
wait.P();

int sumgo(void):
wait.V();
somma = sum;
mutex.P()
sum = 0
mutex.V()
return somma;

</pre>
== 4 ==
<pre>
queue<int> processlist;
semaphore mutex(1);
semaphore s(0);

void sumstop(int v):
mutex.P();
processlist.enqueue(v);
mutex.P();
S.P();

int sumgo(void):
int sum = 0;
mutex.P();
while processlist.top() != NULL:
sum += processlist.dequeue();
S.V();
mutex.V()
return sum;

</pre>
== 5 ==
<pre>
int counter = 0;
int sum = 0;
semaphore mutex(1);
semaphore blocked(0);

void sumstop(int v):
mutex.P();
sum+=v;
counter++;
mutex.V();
blocked.P();

int sumgo(void):
mutex.P();
intret = sum;
sum = 0;
for (int i=0; i<counter; i++)
blocked.V()
counter = 0;
mutex.V()
return intret

</pre>
== 6 ==
<pre>
int sum = 0;
mutex = new semaphore(1);
queue q;

void sumstop(int v):
mutex.P();
sum += v;
sintpid = getpid();
suspend(pid);
mutex.V();

int sumgo(void):
mutex.P();
while !q.empty():
resume(q.dequeue())
int value = sum;
sum = 0;
return value;

</pre>
== 7 ==
<pre>
int nP, nV = -1, 0;
int somma = 0
int val[]
semaphore mutex(1);
semaphore s(0);

void sumstop(int v):
mutex.P()
val[nP++].add[v]
s.P()
np--
v[0].delete

int sumgo(void):
mutex.P();
nV++
if nP > 0:
s.V()
for (int i=0; i<nV; i++)
somma += val[i]
nv--
else
mutex.V()
return somma

</pre>
== 8 ==
<pre>
struct blocked {
semaphore sem(0);
int value = 0;
};

semaphore mutex(1);
list<blocked> procs = new list<blocked>();

void sumstop(int v):
mutex.P()
blocked bl = new blocked();
bl.value = v
procs.add(bl)
bl.sem.P()
mutex.V()

int sumgo(void):
mutex.P();
int count = 0;
foreach proc in procs:
count += proc.value
procs.remove(proc)
proc.sem.V()
mutex.V()
return count;

</pre>
== 9 ==
<pre>
semaphore s[] new sem(0)
semaphore s1 new sem(0)
int tot, waiting = 0;

void sumstop(int v):
waiting++
s[waiting - 1].P()
waiting--
tot = tot + v
if waiting == 0:
s1.V()

int sumgo(void):
if waiting = 0:
return 0
for (i = waiting -1; i == 0; i--)
s[i].V()
s1.P() // per aspettare che tutti abbiano fatto la somma
return tot

</pre>

== 10 ==
<pre>
int nw = 0
int currsum = 0
semaphore mutex(1)
semaphore wait2go(0)

void sumstop(int v):
mutex.P()
currsum += v;
nw++;
mutex.V()
wait2go.P()
if --nw > 0:
wait2go.V()
else
mutex.V()

int sumgo(void):
mutex.P();
if nw == 0:
mutex.V()
return 0;
int sum = cursum;
cursum = 0;
wait2go.V();
return sum

</pre>
== 11==
<pre>
semaphore mutex(1);
semaphore semwait(0);
int sum=0;
int wait=0;

void sumstop(int v):
mutex.P()
wait++
sum += v;
mutex.V()
semwait.P()
mutex.P()
wait--;
mutex.V()
if wait > 0:
semwait.V()

int sumgo(void):
if wait == 0:
return 0
semwait.V();
while (wait > 0) {}
int val = sum
mutex.P()
sum = 0;
mutex.V()
return val;

</pre>
== 12 ==
<pre>
semaphore mutex(0)
volatile int counter = 0

void sumstop(int v):
counter = counter + v;
mutex.P()

int sumgo(void):
int val = counter;
while (mutex.value != 0)
mutex.V()
counter = 0;
return counter

</pre>
== 13 ==
<pre>
semaphore mutex(1)
int sum = 0;
queue of semaphore q;

void sumstop(int v):
mutex.P()
sum += v;
s = new semaphore(0);
q.enqueue(s)
mutex.V()
s.P()
free(s)

int sumgo(void):
mutex.P()
int lsum = sum
sum = 0
while (!q.empty()):
semaphore s = q.dequeue()
s.V()
mutex.V()

</pre>
== 14 ==
<pre>
semaphore mutex(1)
int sum = 0;
queue of semaphore q;

void sumstop(int v):
mutex.P()
sum += v;
s = new semaphore(0);
q.enqueue(s)
mutex.V()
s.P()
free(s)
if(q.empty())
mutex.V()
else
semaphore s = q.dequeue()
s.V()

int sumgo(void):
mutex.P()
int lsum = sum
sum = 0
if(q.empty())
mutex.V()
else
semaphore s = q.dequeue()
s.V()

</pre>

== 15 (soluzione proposta su telegram) ==
<syntaxhighlight lang=C>
#include <pthread.h>
#include "semaphore.h"

semaphore s; // semaforo che blocca le somme
semaphore finished; // semaforo che indica che le somme sono state fatte
semaphore critical_section; // sarà utilizzata per decidere chi entra nella critical section

volatile int sumstops = 0;
volatile int result;

void *sumstop(int v) {
semaphore_P(critical_section);
sumstops++;
semaphore_V(critical_section);

semaphore_P(s);
printf("summed %d\n", v);
result += v;
semaphore_V(finished);
}

int sumgo(void) {
semaphore_P(critical_section); // così sumstops è costante all'interno di questa section
result = 0;
for (int i = 0; i < sumstops; i++) {
semaphore_V(s); // permetti alla somma di andare
semaphore_P(finished); // aspetta che la somma sia finita prima di continuare
}
sumstops = 0; // reset number of blocked stops.
semaphore_V(critical_section);
return result;
}

void *run_sumgo(void) {
int res = sumgo();
printf("the result found is %d\n", res);
printf("the result found is %d\n", result);
}

int main() {
srand(time(NULL));
s = semaphore_create(0);
critical_section = semaphore_create(1);
finished = semaphore_create(0);

int n = rand() % 50;
pthread_t sumg, s[n];

for (int i = 0; i < n; i++) {
pthread_create(&s[i], NULL, sumstop, i);
}
pthread_create(&sumg, NULL, run_sumgo, NULL);

for (int i = 0; i < 10; i++) {
pthread_join(s[i], NULL);
}

pthread_join(sumg, NULL);
}

</syntaxhighlight>

== Correzioni proposte ==

Correzione proposta da [https://t.me/flecarts flecart]
(e poi modificata successivamente da altri studenti ...
tra cui: [https://t.me/LLibera] )

1. la variabile i non è inizializzata, sum e queue non sono protette in critical sections, inoltre la sem.V() non compare mai nel codice della sumgo.

2. la coda value non è in una critical section, può creare errori nell'update di essa, solo sum viene considerata da proteggere, ma devono essere protette entrambe. La enqueue avrebbe senso farla solo prima di bloccarsi nel semaforo, se viene fatta dopo al momento della chiamata di sumgo non ci sono valori all'interno della coda!

3. sumgo libera solamente un singolo sumstop, perché chiama wait.V() una singola volta anche se ci sono più thread in attesa

4. mutex.P() è chiamata due volte in sumstop(), se il secondo fosse mutex.V() credo sia corretto.

5. mi sembra corretto (ma l'indentazione è poco sensata).

6. non si possono utilizzare suspend o resume (non si è fatto uso di semafori, e l'implementazione deve essere fatta all'esterno del kernel non all'interno). Oltre a questo pid non è inizializzata e sintpid non è utilizzata. Se anche la suspend fosse una sem.P() e la resume una sem.V() non dovremmo sospendere il processo all'interno della mutua esclusione.

7. nP e nV mi sembrano superflue, in questo caso sicuramente scorrette perché se chiamo m volte sumstop e una volta sumgo, nV è al massimo 1
quindi è impossibile che riesca a contare correttamente tutte le somme.

8. Deadlock perché bl.sem.P() è chiamato prima che ls Critical Section venga rilasciata e sumgo ha bisogno di entrare in una CS.

9. waiting è una variabile globale modificata senza cs, e tot non è inizializzato.

10. simile a 3. wait2go è chiamata una volta quindi può liberare solamente un singolo thread di sumstop.

11. busy waiting in sumgo.

12. counter non è protetto da Critical section

13. se sumgo ritornasse il valore lsum sarebbe tutto apposto.

14. mi sembra corretto

15. mi sembra corretto

20220906c2

2022-10-19T23:03:14Z

LiberaL: /* Correzioni aggiunte alle proposte */

In questa pagina sono presenti alcune soluzioni (possibilmente con errore) per l'esercizio C2 dell'esame 2022/09/06.
Il lettore è invitato a immedesimare il professore al momento della correzione durante la lettura delle soluzioni.

== Consegna ==
Usando i semafori implementare un servizio che preveda due funzioni:
void sumstop(int v)
int sumgo(void)
La funzione sumstop deve mettere il processo chiamante in attesa.
La funzione sumgo deve sbloccare tutti i processi messi in attesa con la sumstop e restituire la somma algebrica dei valori passati come parametro alla sumstop dai processi che sono stati sbloccati (zero se la sumgo viene richiamata quando non c'è nessun processo bloccato).
== 1 ==
<pre>
semaphore sem(1);
int sum=0;
queue q;

void sumstop(int v):
if i < 0:
q.enqueue(v)
sem.P()
else
i--

int sumgo(void):
for each elem in q:
int val=q.dequeue()
sum=sum + val
return sum

</pre>
== 2 ==
<pre>
queue values;
semaphore s(0);
int sum=0;

void sumstop(int v):
s.P()
values.enqueue(v)

int sumgo(void):
while !value.isEmpty():
s.V()
mutex.P()
sum=sum+values.dequeue()
mutex.v()
return sum

</pre>
== 3 ==
<pre>
shared int sum=0;
semaphore wait(0);
semaphore mutex(1);

void sumstop(int v):
mutex.P();
sum = sum + v;
mutex.V();
wait.P();

int sumgo(void):
wait.V();
somma = sum;
mutex.P()
sum = 0
mutex.V()
return somma;

</pre>
== 4 ==
<pre>
queue<int> processlist;
semaphore mutex(1);
semaphore s(0);

void sumstop(int v):
mutex.P();
processlist.enqueue(v);
mutex.P();
S.P();

int sumgo(void):
int sum = 0;
mutex.P();
while processlist.top() != NULL:
sum += processlist.dequeue();
S.V();
mutex.V()
return sum;

</pre>
== 5 ==
<pre>
int counter = 0;
int sum = 0;
semaphore mutex(1);
semaphore blocked(0);

void sumstop(int v):
mutex.P();
sum+=v;
counter++;
mutex.V();
blocked.P();

int sumgo(void):
mutex.P();
intret = sum;
sum = 0;
for (int i=0; i<counter; i++)
blocked.V()
counter = 0;
mutex.V()
return intret

</pre>
== 6 ==
<pre>
int sum = 0;
mutex = new semaphore(1);
queue q;

void sumstop(int v):
mutex.P();
sum += v;
sintpid = getpid();
suspend(pid);
mutex.V();

int sumgo(void):
mutex.P();
while !q.empty():
resume(q.dequeue())
int value = sum;
sum = 0;
return value;

</pre>
== 7 ==
<pre>
int nP, nV = -1, 0;
int somma = 0
int val[]
semaphore mutex(1);
semaphore s(0);

void sumstop(int v):
mutex.P()
val[nP++].add[v]
s.P()
np--
v[0].delete

int sumgo(void):
mutex.P();
nV++
if nP > 0:
s.V()
for (int i=0; i<nV; i++)
somma += val[i]
nv--
else
mutex.V()
return somma

</pre>
== 8 ==
<pre>
struct blocked {
semaphore sem(0);
int value = 0;
};

semaphore mutex(1);
list<blocked> procs = new list<blocked>();

void sumstop(int v):
mutex.P()
blocked bl = new blocked();
bl.value = v
procs.add(bl)
bl.sem.P()
mutex.V()

int sumgo(void):
mutex.P();
int count = 0;
foreach proc in procs:
count += proc.value
procs.remove(proc)
proc.sem.V()
mutex.V()
return count;

</pre>
== 9 ==
<pre>
semaphore s[] new sem(0)
semaphore s1 new sem(0)
int tot, waiting = 0;

void sumstop(int v):
waiting++
s[waiting - 1].P()
waiting--
tot = tot + v
if waiting == 0:
s1.V()

int sumgo(void):
if waiting = 0:
return 0
for (i = waiting -1; i == 0; i--)
s[i].V()
s1.P() // per aspettare che tutti abbiano fatto la somma
return tot

</pre>

== 10 ==
<pre>
int nw = 0
int currsum = 0
semaphore mutex(1)
semaphore wait2go(0)

void sumstop(int v):
mutex.P()
currsum += v;
nw++;
mutex.V()
wait2go.P()
if --nw > 0:
wait2go.V()
else
mutex.V()

int sumgo(void):
mutex.P();
if nw == 0:
mutex.V()
return 0;
int sum = cursum;
cursum = 0;
wait2go.V();
return sum

</pre>
== 11==
<pre>
semaphore mutex(1);
semaphore semwait(0);
int sum=0;
int wait=0;

void sumstop(int v):
mutex.P()
wait++
sum += v;
mutex.V()
semwait.P()
mutex.P()
wait--;
mutex.V()
if wait > 0:
semwait.V()

int sumgo(void):
if wait == 0:
return 0
semwait.V();
while (wait > 0) {}
int val = sum
mutex.P()
sum = 0;
mutex.V()
return val;

</pre>
== 12 ==
<pre>
semaphore mutex(0)
volatile int counter = 0

void sumstop(int v):
counter = counter + v;
mutex.P()

int sumgo(void):
int val = counter;
while (mutex.value != 0)
mutex.V()
counter = 0;
return counter

</pre>
== 13 ==
<pre>
semaphore mutex(1)
int sum = 0;
queue of semaphore q;

void sumstop(int v):
mutex.P()
sum += v;
s = new semaphore(0);
q.enqueue(s)
mutex.V()
s.P()
free(s)

int sumgo(void):
mutex.P()
int lsum = sum
sum = 0
while (!q.empty()):
semaphore s = q.dequeue()
s.V()
mutex.V()

</pre>
== 14 ==
<pre>
semaphore mutex(1)
int sum = 0;
queue of semaphore q;

void sumstop(int v):
mutex.P()
sum += v;
s = new semaphore(0);
q.enqueue(s)
mutex.V()
s.P()
free(s)
if(q.empty())
mutex.V()
else
semaphore s = q.dequeue()
s.V()

int sumgo(void):
mutex.P()
int lsum = sum
sum = 0
if(q.empty())
mutex.V()
else
semaphore s = q.dequeue()
s.V()

</pre>

== 15 (soluzione proposta su telegram) ==
<syntaxhighlight lang=C>
#include <pthread.h>
#include "semaphore.h"

semaphore s; // semaforo che blocca le somme
semaphore finished; // semaforo che indica che le somme sono state fatte
semaphore critical_section; // sarà utilizzata per decidere chi entra nella critical section

volatile int sumstops = 0;
volatile int result;

void *sumstop(int v) {
semaphore_P(critical_section);
sumstops++;
semaphore_V(critical_section);

semaphore_P(s);
printf("summed %d\n", v);
result += v;
semaphore_V(finished);
}

int sumgo(void) {
semaphore_P(critical_section); // così sumstops è costante all'interno di questa section
result = 0;
for (int i = 0; i < sumstops; i++) {
semaphore_V(s); // permetti alla somma di andare
semaphore_P(finished); // aspetta che la somma sia finita prima di continuare
}
sumstops = 0; // reset number of blocked stops.
semaphore_V(critical_section);
return result;
}

void *run_sumgo(void) {
int res = sumgo();
printf("the result found is %d\n", res);
printf("the result found is %d\n", result);
}

int main() {
srand(time(NULL));
s = semaphore_create(0);
critical_section = semaphore_create(1);
finished = semaphore_create(0);

int n = rand() % 50;
pthread_t sumg, s[n];

for (int i = 0; i < n; i++) {
pthread_create(&s[i], NULL, sumstop, i);
}
pthread_create(&sumg, NULL, run_sumgo, NULL);

for (int i = 0; i < 10; i++) {
pthread_join(s[i], NULL);
}

pthread_join(sumg, NULL);
}

</syntaxhighlight>

== Correzioni proposte ==

Correzione proposta da [https://t.me/flecarts flecart] (e poi modificata successivamente da altri studenti ...)

1. la variabile i non è inizializzata, sum e queue non sono protette in critical sections, inoltre la sem.V() non compare mai nel codice della sumgo.

2. la coda value non è in una critical section, può creare errori nell'update di essa, solo sum viene considerata da proteggere, ma devono essere protette entrambe. La enqueue avrebbe senso farla solo prima di bloccarsi nel semaforo, se viene fatta dopo al momento della chiamata di sumgo non ci sono valori all'interno della coda!

3. sumgo libera solamente un singolo sumstop, perché chiama wait.V() una singola volta anche se ci sono più thread in attesa

4. mutex.P() è chiamata due volte in sumstop(), se il secondo fosse mutex.V() credo sia corretto.

5. mi sembra corretto (ma l'indentazione è poco sensata).

6. non si possono utilizzare suspend o resume (non si è fatto uso di semafori, e l'implementazione deve essere fatta all'esterno del kernel non all'interno). Oltre a questo pid non è inizializzata e sintpid non è utilizzata. Se anche la suspend fosse una sem.P() e la resume una sem.V() non dovremmo sospendere il processo all'interno della mutua esclusione.

7. nP e nV mi sembrano superflue, in questo caso sicuramente scorrette perché se chiamo m volte sumstop e una volta sumgo, nV è al massimo 1
quindi è impossibile che riesca a contare correttamente tutte le somme.

8. Deadlock perché bl.sem.P() è chiamato prima che ls Critical Section venga rilasciata e sumgo ha bisogno di entrare in una CS.

9. waiting è una variabile globale modificata senza cs, e tot non è inizializzato.

10. simile a 3. wait2go è chiamata una volta quindi può liberare solamente un singolo thread si sumstop.

11. busy waiting in sumgo.

12. counter non è protetto da Critical section

13. se sumgo ritornasse il valore lsum sarebbe tutto apposto.

14. mi sembra corretto

15. mi sembra corretto