Prova teorica 2017.05.29

link al compito

Esercizio c.1

Soluzione di Save

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

Monitor rubaBandiera () {

  condition oktochiama, oktopunteggio, oktopronto; 

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

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

 procedure entry gioco() {
   
  
      n=random(listnum);
      numeri(n)=random(numeriChiamati);

      if( studentiPronti == false)

             oktochiama(numeri).wait() ;

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

    while(studentiPronti(numeri))

         oktochiama(numeri).signal();
}


 procedure entry chiama () {

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

         oktopunteggio.wait()

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

      pronto();

 procedure entry pronto() {

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

        return 0;
      else return 1;
}}

Secondo devi utilizzare il nome corretto per le procedure entry, cioè mancano nuovapartita e allabandiera, che non hai definito. Con i corretti parametri. --FedericoB (talk) 18:45, 15 June 2017 (CEST)

Soluzione di Stefano Zaniboni

Monitor rb () {

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

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

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

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

Esercizio c.2

Soluzione di Stefano Zaniboni

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

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

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

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

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

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

Esercizio g.1

Soluzione di GiovanniF

min = lifo 1234123124123124...

lifo = lru 123124123124123124...

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

MIN
1	2	3	4	1	2	3	1	2	4	1	2	3	1	2	4
1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1
	2	2	2	2	2	2	2	2	2	2	2	2	2	2	2
		3	4	4	4	3	3	3	4	4	4	3	3	3	4
			#			#			#			#			#

LIFO
1	2	3	4	1	2	3	1	2	4	1	2	3	1	2	4
1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1
	2	2	2	2	2	2	2	2	2	1	2	2	2	2	2
		3	4	4	4	3	3	3	4	4	4	3	3	3	4
			#			#			#			#			#

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

LRU
1	2	3	1	2	4	1	2	3	1	2	4	1	2	3
1	1	1	1	1	1	1	1	1	1	1	1	1	1	1
	2	2	2	2	2	2	2	2	2	2	2	2	2	2
		3	3	3	4	4	4	3	3	3	4	4	4	4
					#			#			#			#

LIFO
1	2	3	1	2	4	1	2	3	1	2	4	1	2	3
1	1	1	1	1	1	1	1	1	1	1	1	1	1	1
	2	2	2	2	2	2	2	2	2	2	2	2	2	2
		3	3	3	4	4	4	3	3	3	4	4	4	4
					#			#			#			#

Esercizio g.2

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