Prove svolte e soluzioni proposte

Questa pagina serve a raccogliere prove d'esame svolte (che possono essere utili alla preparazione) e soluzioni proposte a tali prove da sottoporre a peer-review.

Esame 19/09/2018

2018.09.19.tot.pdf

Esercizio c.1 (sbagliato)

// Condition: MAX
// Condition: ok2load
// Condition: ok2unload
// Condition: ok2move

int airport_codes = [BLQ, CDG, BRX, LGW, FCO, ...]
struct luggage {
    int dstcode;
    int owner;
};
luggage cart[MAX];
int loaded = 0;

Procedure entry: void cartat(int code)
{
    if(code == 0)
    {
        ok2unload.wait();
        ok2load.signal();
    }
    else
    {
        ok2load.wait();
        ok2unload.signal();
    }
}

Procedure entry: void load(int dstcode, int owner)
{
    ok2move.wait();
    if(loaded < MAX)
    {
        luggage l;
        l.dstcode = dstcode;
        l.owner = owner;
        cart.push(l);
        loaded++;
    }
    else ok2move.signal();
}

Procedure entry: int unload(int dstcode)
{
    ok2move.wait();
    int i;
    for(i=0; i<loaded; i++)
    {
        if(cart[i].dstcode == dstcode)
        {
            int owner = cart[i].owner;
            cart[i].remove();
            loaded--;
            return owner;
        }
    }
    else ok2move.signal();
}

Esercizio c.1

monitor dispatch
condition go_cart;
condition ok2station; // quando la stazione può caricare
current_station = None
// dizionario con chiave destinazione
luggages = {}

def countl(luggages):
    n=0
    for d in luggages:
        n += len(luggages[d]);

p.e. cartat(code):
    current_station = code // carrello arriva alla stazione
    if (code == BLQ || len(luggages[code]) > 0):
        ok2station[code].signal()
        go_cart.wait()
    current_station = None // il carrello sta viaggiando tra le stazioni

p.e. load(dst, owner):
    if (current_station != BLQ || countl(luggages) >= MAX):
        ok2station(BLQ).wait()
    luggages[dst].append(owner)
    if (countl(luggages) >= MAX)
        go_cart.signal()
    
p.e. unload(dst):
    if (current_station != dst || len(luggages[dst]) == 0)
    // lunghezza lista dei bagagli con questa destinazione
        ok2station(dst).wait()
    owner = luggages[dst].pop()
    if len(luggages[dst]) == 0)
        go_cart.signal()
    return owner

Esercizio c.2

/* MP sincrono dato quello asincrono */

void ssend(obj msg, process q)
{
    asend(msg, q);
    ack = areceive(q);
}

obj sreceive(process p)
{
    obj msg = areceive(p);
    asend(ack, p);
    return msg;
}

Soluzione:

dati asend/arecv devo implementare lssend lsrecv

lssend(dst, msg):
    asend(dst, (MSG, myid(), msg))
    arecv(dst)

lsrecv(snd):
    asend(myid(), (TAG, myid(), NULL))    // mi mando un messaggio che riesco a riconoscere
    while True:
        (T, s, m) =  arecv(ANY)           // continua a ricevere finchè non ricevi il mio messaggio
        if (T != TAG) data.push(s, m)
        else break
    while (((s,m) = data.pop(snd) == NULL):   // c'è il messaggio di src definito?
        (T, s, m) =  arecv(ANY)
        data.push(s, m)
    asend(s, (ACK, myid(), NULL)
    return m

Esercizio g.1 (sbagliato)

x = long_compute()/short_compute()
X = io()

   0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 8 8 8
   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2
P1 |x|x|x|x|x|X|-|-|-|-|-|-|X|X|X|-|-|-|-|-|-|X|x|x|-|-|-|-|-|-|x|x|x|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|X|X|X|-|-|-|-|-|-|X|X|x|-|-|-|-|-|-|x|-|-|
P2         |-|-|x|x|x|-|-|-|-|-|-|x|x|-|-|-|-|-|-|-|X|X|X|-|-|-|-|-|-|X|X|x|-|-|-|-|-|-|x|x|x|-|-|-|-|-|-|x|-|-|-|-|-|-|-|-|X|X|X|-|-|-|-|-|-|X|X|x|-|-|-|x|-|-|
P3               |-|-|x|x|x|-|-|-|-|-|-|x|x|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|X|X|X|-|-|-|-|-|-|X|X|x|-|-|-|-|-|-|x|x|x|-|-|-|-|-|-|x|-|-|-|-|-|-|-|-|X|X|X|-|-|-|X|X|x|x|
 

Esercizio g.1

P1(start=0): 5ms CPU, 5ms IO, 5ms CPU, 5ms IO, 2ms CPU
P2(start=4): 5ms CPU, 5ms IO, 5ms CPU, 5ms IO, 2ms CPU
P3(start=7): 5ms CPU, 5ms IO, 5ms CPU, 5ms IO, 2ms CPU

 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 5 
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 
P|1 1 1|1 1|2 2 2|3 3 3|2 2|1 1 1|3 3|1 1|2 2 2*3 3 3|2 2|3 3|1 1|-|2 2|- - -|3 3|
I          |1 1 1 1 1|     |2 2 2 2 2|3 3 3 3 3|1 1 1 1 1|2 2 2 2 2|3 3 3 3 3|

r - - - - 2 - - 3 2 2 2 1 1 3 3 3 1 1 2 2 - - - 2 2 2 3 3 1 1
                      1 3 3

* 3 ha finito input output e 2 è ancora in esecuzione quindi c'è da scegliere
 

Esercizio g.2 (da controllare)

a) Può richiedere supporto hardware. Se implementato con contatori o stack questi devono essere aggiornati ad ogni riferimento alla memoria. L'intero sistema viene appesantito e rallentato.
b) Il journaling si assicura che i dati sul filesystem siano consistenti, ma non aggiornati. Assicura la coerenza dei dati, ma non la perdita dei file se il filesystem si danneggia.
c) Si dice che un programma A ha lo stesso potere espressivo di un programma B quando è possibile esprimere ogni programma scritto con B mediante A. Per implementare MP sincrono dato quello asincrono basta aggiungere una libreria. Per implementare MP asincrono dato quello sincrono bisogna aggiungere un processo server.
d) In questi casi tutte le istruzioni vengono eseguite con la massima autorità, con problemi di sicurezza nel caso un utente estraneo prenda il controllo del sistema o rischio di commettere gravi errori semplicemente sbagliando a digitare un comando.

Esame 17/07/2018

2018.07.17.tot.pdf

Esercizio c.1

/* 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();
    }
}

Esercizio c.2

stack s;
semaphore mutex(1); // mutua esclusione
semaphore ok2consume(0);

Procedure entry: void push(int value)
{
    mutex.P();
    s.push(value)
    mutex.V()
    ok2consume.V()
}

Procedure entry: int pop()
{
    int value;
    ok2consume.P();
    mutex.P();
    value = s.pop();
    mutex.V();
    return value;
}

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.

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
}

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)

a) Nei sistemi embedded o in computer ad uso specifico in cui sono richiesti tempi di risposta molto rapidi. La memoria virtuale può generare ritardi imprevedibili e può richiedere un supporto hardware per la traduzione da indirizzi virtuali ad indirizzi fisici. Ma in sistemi embedded non sempre c'è spazio fisico per implementare questi supporti hardware.
b) 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.
c) Serve ad aumentare le performance, rendere il sistema resiliente alla perdita di uno o più dischi e poterli rimpiazzare senza interrompere il servizio. RAID serve per tutelarsi dai problemi hardware, non sostituisce i backup in quanto ci permette solo di proseguire il lavoro, non ci permette di recuperare file cancellati o bloccati da ransomware.
d) Per dimostrare questo occorre una variante del grafo di Holt, detto grafo Wait-For, che si costruisce eliminando i nodi di tipo risorsa e collassando gli archi appropriati, per cui il grafo di Holt contiene un ciclo se e solo se il grafo Wait-For contiene un ciclo e pertanto si ha l'attesa circolare (deadlock).

Esame 21/06/2018

2018.06.21.tot.pdf

Esercizio c.1 (sbagliato)

/* 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();
    }
}

Esercizio c.1

/* 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();
}

Esercizio c.2 (sbagliato)

#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();        
    }
}

Esercizio c.2

Soluzione "furba e facile"

#define N n // limite operazioni
class lim_semaphore()
{
    semaphore plus;
    semaphore minus;
    int value;   //serve per significato
    
    init(x) : { value=x; plus.init(N+x); minus.init(N-x);}   //costruttore
    P() : { plus.P(); value--; minus.V(); }
    V() : { minus.P(); value++; plus.V(); }
}

Soluzione "schiacciasassi"

#define N n // limite operazioni

class lim_semaphore()
{
    semaphore mutex;
    queue of semaphore okmin, okmax;
    int value;
    init(x) : { value=x; }
    P() {
        mutex.P();
        if (value <= -N)  {
            s=semaphore(0);
            okmin.enqueue(s);
            mutex.V();
            s.P();
            mutex.V();
        } else if (okmax.length() > 0) {
            s = okmax.dequeue()
            s.V();
        } else {
            value--;
            mutex.V();
        }
    }
    V() {
        mutex.P();
        if (value >= -N)  {
            s=semaphore(0);
            okmax.enqueue(s);
            mutex.V();
            s.P();
            mutex.V();
        } else if (okmin.length() > 0) {
            s = okmin.dequeue()
            s.V();
        } else {
            value++;
            mutex.V();
        }
    }
}

Esercizio g.1

IC = 10,10,10
COH = 4,4,4
 
      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

Minimizzato

IC = 4,4,4     //massimo
COH = 1,1,1    //soldi in cassa
 
      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

Esercizio g.2 (da controllare)

a) L'algoritmo di calcolo del working set serve a limitare il problema del trashing assicurandosi che le pagine di cui ha bisogno un processo (una loro approssimazione) siano già caricate in memoria prima di far partire il processo stesso. L'algoritmo viene eseguito ogni volta che avviene un page fault, cercando una pagina "vittima" non presente nel working set e sfrattandola, facendo posto alla pagina che occorre al processo in esecuzione.
b) 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.
c) Un virus necessità l'intervento umano per essere avviato o per essere diffuso. Si attacca a programmi o file per potersi diffondere. Un worms è in grado di riprodursi e di diffondersi autonomamente, sfruttando le informazioni presenti sul computer.
d) La ready queue di uno scheduler può essere vuota quando tutti i processi sono in esecuzione su diversi processori, oppure quando tutti i processi hanno terminato la loro esecuzione. È un caso fisiologico della vita di un sistema.

Esame 12/02/2018

2018.02.12.tot.pdf

Esercizio c.1 (da controllare)

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();
      }
  }

Esercizio c.1 tentativo soluzione2 (da controllare)

#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

p.e. 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--;
}

p.e. car_exit(int direction){
    carsOnBridge--;
    last2pass = car;
    if(carsOnBridge == 0 && waitingS>0){
        isBrigdeUp = true;
        ok2ship.signal;
    }
}

p.e. 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;
    
    }
}

p.e. 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;    
    }
}

Esame 11/09/2017

2017.09.11.tot.pdf

Esercizio c.1 (da controllare)

monitor crossing{
    condition ok2passN;
    condition ok2passE;
    condition ok2passS;
    condition ok2passW;

    bool crossingOccupied = false;
    //numero di auto che aspettano da direzione
    int waitingN = 0; 
    int waitingE = 0;
    int waitingS = 0;
    int waitingw = 0;

p.e. enter  (direction){
    switch (direction)
    {
        case Nord:
            //si ferma se l'incrocio è occupato
            if(crossingOccupied)
                waitingN ++;
                ok2passN.wait;
            crossingOccupied = true;
            waitingN--;
        break;
        
        case EST:
        //aggiungo il caso di blocco anche quando ci sono 4 macchine all'incrocio poiche deve passare N
            if(crossingOccupied ||(waitingN > 0 && waitingS > 0 && waitingW > 0))
                waitingE ++;
                ok2passE.wait;
            crossingOccupied = true;
            waitingE--;
        break;
        
        case SUD:
            if(crossingOccupied ||(waitingE > 0 && waitingN > 0 && waitingW > 0))
                waitingS ++;
                ok2passS.wait;
            crossingOccupied = true;
            waitingS--;
        break;      
        
        case WEST:
            if(crossingOccupied ||(waitingE > 0 && waitingS > 0 && waitingW > 0))
                waitingW ++;
                ok2passW.wait;
            crossingOccupied = true;
            waitingW--;
        break;
}

p.e. exit(direction){
    switch (direction)
    {
        case Nord:
            crossingOccupied = false;
            if(waitingE > 0)
                ok2passE.signal;
            else if (waitingS > 0)
                ok2passE.signal;
            else if (waitingW > 0)
                ok2passW.signal;
            else
                ok2passN.signal;
            break;
        
        case EST:
            crossingOccupied = false;
            if(waitingS > 0)
                ok2passS.signal;
            else if (waitingW > 0)
                ok2passW.signal;
            else if (waitingN > 0)
                ok2passN.signal;
            else
                ok2passE.signal;
   
        break;
        
        case SUD:
            crossingOccupied = false;
            if(waitingW > 0)
                ok2passW.signal;
            else if (waitingN > 0)
                ok2passN.signal;
            else if (waitingE > 0)
                ok2passE.signal;
            else
                ok2passS.signal;
   
            break;      
        
        case WEST:
            crossingOccupied = false;
            if(waitingN > 0)
                ok2passN.signal;
            else if (waitingE > 0)
                ok2passE.signal;
            else if (waitingS > 0)
                ok2passS.signal;
            else
                ok2passW.signal;
   
            break;
}

}
}

Esame 29/05/2017

2017.05.29.tot.pdf

Esercizio c.1

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

p.e. nuovapartita():
{
    punteggio[A] = punteggio[B] = 0;
    numpronti = 0;
    partita=true;
    okpartita.signal()
    chiamati = [];
}
p.e. 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;
}
p.e. 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();
    }
}

Esame 16/07/2014

2014.07.16.tot.pdf

Esercizio c.1

/* Monitor Bounded Buffer: (non richiesto dall'esercizio) */
queue q;
condition oktoread; // q.length() > 0
condition oktowrite; // q.length() < MAX

procedure entry type read():
    if (q.length() == 0) oktoread.wait(); // controllo
    retval = q.dequeue(); // cambio lo stato
    // abilito coloro che possono essere abilitati dal cambiamento di stato
    oktowrite.signal() 
    return retval;

procedure entry void write(type elem):
    if (q.length() >= MAX) oktowrite.wait(); //controllo
    q.enqueue(elem); // cambio lo stato
    oktoread.signal(); // abilito chi può essere abilitato

/* NOTE:
 * procedure entry ==> dichiarazione di funzioni (senza vedere l'implementazione 
 * dall'esterno)
 */

/* Min-Max Monitor Bounded Buffer: */

Queue Q;

// Condition: OKTOREAD: Q.Length > MIN
// Condition: OKTOWRITE: Q.Length < MAX

procedure entry: Type Read():
{
    if (Q.Length <= MIN) OKTOREAD.Wait(); // Controllo
    retval = Q.Dequeue(); // Cambio di stato
    OKTOWRITE.Signal(); // Abilito chi vuole scrivere
    return retval; // Qui sono sicuro perchè ne ho eliminato uno prima
}

procedure entry: void Write(Type elem):
{
    if (Q.Length >= MAX) OKTOWRITE.Wait() // Controllo
    Q.Enqueue(elem); // Cambio di stato
    if (Q.Length > MIN) OKTOREAD.Signal(); // Abilito chi vuole leggere
}

Esercizio c.2

Semaphore mutex = 1;

struct Elem
{
    Semaphore s;
    int counter;
}

struct Elem V[]; // Vettore a dimensione variabile. I nuovi elementi sono initializzati a s = 0, counter = 0.

void RendezVouz(int n)
{
    mutex.P(); // Blocco, decremento di 1 (il processo si blocca se il semaforo vale 0)
    V[n].counter++;
    if (V[n].counter < n)
    {
        mutex.V(); // Rilascia, incrementa di 1
        V[n].s.P();
    }
    V[n].counter--;
    if (V[n].counter > 0)
        V[n].s.V();
    else
        mutex.V();       
}

Esercizio g.1

   0241302 ==> soluzione corretta

(0)2 2200 (1)3 1111 (2)4 4442 (3)0 0333

   2 3 4 0 1 2 3 4  0  1  2  3 ==> soluzione proposta, non corretta perchè non è la stringa più corta 

2 1 1 1 1 0 0 0 0 3 3 2 2 2 2 1 1 1 4 4 4 3 3 3 3 2 2 0 0 0 0 4 4 4 4 3

Esame Pratico 19/09/2018

[1]

Esercizio 1 (da controllare)

 
   #define _GNU_SOURCE  
   #include <stdio.h>
   #include <unistd.h>
   #include <sys/types.h>
   #include <sys/stat.h>
   #include <fcntl.h>
   #include <signal.h>
   #include <time.h>
   #include <sys/signalfd.h>
   #include <string.h>



int main(int argc, char *argv[]){
	sigset_t mask;
	int sfd;
	int fd;
	struct signalfd_siginfo fdsi;
	char* pid;
	char* message;
	time_t linuxtime;
	char* actual_time;
	ssize_t s;

	sigemptyset(&mask);
	sigaddset(&mask, SIGUSR1);
	sigaddset(&mask, SIGUSR2);
	
	sigprocmask(SIG_BLOCK, &mask, NULL);
	
	sfd = signalfd(-1, &mask, 0);

	while(1){
		s = read(sfd, &fdsi, sizeof(struct signalfd_siginfo));
		
		if (s > 0 && fdsi.ssi_signo == SIGUSR1){
			asprintf(&pid,"./%u", fdsi.ssi_pid);
			fd = open(pid, O_WRONLY | O_CREAT | O_APPEND);
			time(&linuxtime);
			actual_time = ctime(&linuxtime);
			asprintf(&message,"USR1 %s\n" ,actual_time); 
			write(fd, message, strlen(message));
		}
		} 
		else if (s > 0 && fdsi.ssi_signo == SIGUSR2){
   		     asprintf(&pid,"./%u", fdsi.ssi_pid);
	    	     fd = open(pid, O_WRONLY | O_CREAT | O_APPEND);
        	     time(&linuxtime);
        	     actual_time = ctime(&linuxtime);
        	     asprintf(&message,"USR2 %s\n" ,actual_time);
	             write(fd, message, strlen(message));
		}
	}		
}

</nowiki>