Difference between revisions of "Prova Teorica 2013.06.21"

From Sistemi Operativi
Jump to navigation Jump to search
 
(7 intermediate revisions by 3 users not shown)
Line 1: Line 1:
 
<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.06.21.tot.pdf Testo del compito]</h1>
 
<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.06.21.tot.pdf Testo del compito]</h1>
 +
 +
<h2> Esercizio c.1 </h2>
 +
 +
<syntaxhighlight lang="C">
 +
 +
monitor nvie
 +
{
 +
condition oktoread;
 +
queue buffer[N];
 +
 +
 +
procedure entry put(int n, generic object)
 +
{
 +
 +
                          if (buffer[n].length < NELEM)
 +
buffer[n].enqueue(object);
 +
 +
          oktoread.signal();
 +
 +
}
 +
 +
procedure entry generic get(generic *object)
 +
{
 +
 +
              int count=0;
 +
 +
for (int i=0;i<N;i++)
 +
                        { 
 +
                            if (buffer[i].length>0)
 +
                                  count++;
 +
                            return None ;
 +
                        }
 +
for (int j=0;j<N;j++)
 +
                        {  if (count>=N/2)
 +
                                (buffer[j].dequeue(*object) ;
 +
                            oktoread.wait();
 +
                        }
 +
      }
 +
}
 +
 +
Save
 +
</syntaxhighlight>
 +
 +
 +
 +
 
<h2> Esercizio g.1 </h2>
 
<h2> Esercizio g.1 </h2>
 
[[http://so.v2.cs.unibo.it/wiki/images/0/02/G1paginazione.jpg soluzione]]
 
[[http://so.v2.cs.unibo.it/wiki/images/0/02/G1paginazione.jpg soluzione]]
−
<h2> Esercizio c.2 </h2>
 
−
<syntaxhighlight lang="C">
 
  
−
#casi possibili dei processi con risultato
+
<h2> Esercizio g.1 </h2>
 +
 
 +
  P1 2 2 2 2 2
 +
  P2 3 2 3 2 3
 +
  P3 1 2 1 2 1
 +
 
 +
NON-PREEMPTIVE
 +
 
 +
  CPU |1|1|2|2|2|1|1|2|2|2|1|1|2|2|2|3| | |3| | |3|
 +
  RQ  |2|2|1|1|1|2|2|1|1|1|2|2|3|3|3| | | | | | | |
 +
      |3|3|3|3|3|3|3|3|3|3|3|3| | | | | | | | | | |
 +
  IO1 | | |1|1| | | |1|1| | | | | | | | | | | | | |
 +
  IO2 | | | | | |2|2| | | |2|2| | | | | | | | | | |         
 +
  IO3 | | | | | | | | | | | | | | | | |3|3| |3|3| |
 +
 
 +
PREEMPTIVE
 +
 
 +
  CPU |1|1|2|2|1|1|2|3|1|1|2|2|2|3|2|2|2|3|
 +
  RQ  |2|2| | |2|2| | | |2|3|3|3| | | |3| |
 +
      |3|3|3|3|3|3|3| | | | | | | | | | | |
 +
  IO1 | | |1|1| | |1|1| | | | | | | | | | |
 +
  IO2 | | | | | | | |2|2| | | | |2|2| | | |
 +
  IO3 | | | | | | | | |3|3| | | | |3|3| | |
 +
 
 +
<h2> Esercizio g.2 </h2>
 +
 
 +
a) quali sono le differenze fra la paginazione e la segmentazione nella gestione della memoria?
 +
 
 +
PAGINAZIONE
 +
Dimensioni pagina fissa; suddivisione automatica; le pagine possono contenere informazioni disomogenee (codice, dati); una pagina ha un indirizzo; dim tipiche: 1-4KB
 +
 
 +
SEGMENTAZIONE
 +
Dimensioni variabili; la suddivisione in segmenti e' compito del programmatore; i segmenti contengono dati omogenei; un segmento ha un nome; dim tipica: 64KB-1MB
 +
 
 +
 
 +
 
 +
b) quali sono le differenze fra le operazioni P e V dei semafori e le operazioni wait/signal delle variabili di condizione?
 +
 
 +
Signal() non ha alcun effetto se nessun processo sta attendendo la condizione. V memorizza il verificarsi degli eventi.
 +
Wait() e' sempre bloccante. P, se il semaforo ha valore positivo, no.
 +
Il processo risvegliato dalla signal viene eseguito per primo.
 +
 
 +
 
 +
c) allocazione contigua, concatenata e indicizzata nei file system, quali sono le differenze e i campi di applicazione?
 +
 
 +
Nell'allocazione contigua ogni file viene allocato in blocchi di memoria adiacenti.
 +
 
 +
PRO: non sono presenti strutture di collegamento, l'accesso sequenziale è efficiente. Anche l'accesso diretto risulta efficiente.
 +
 
 +
CON: frammentazione esterna, politica scelta blocchi liberi da usare; i file non possono crescere
 +
 
 +
APP: e'utilizzato nell'ISO 9660 (dischi ottici) e nel file system NTFS.
 +
 
 +
 
 +
Nell'allocazione concatenata ogni file è una lista concatenata di blocchi ed ogni blocco contiene un puntatore al blocco successivo.
  
−
PQPQQ (((val +1) *2) +1) * 2 * 2 → 12
+
PRO: accesso sequenziale o in append mode efficiente, risolve la frammentazione esterna
−
PQQPQ (( val +1 ) * 2 * 2) +1 * 2 → 12
 
−
QQPQP (((val * 2 * 2) + 1 )* 2) + 1 → 11
 
−
QPQQP (((val * 2) + 1) * 2 * 2) + 1 → 13
 
−
QPQPQ ((((val * 2) + 1) * 2) + 1) * 2 → 14
 
  
 +
CON: l'accesso diretto è inefficiente, se il blocco è piccolo l'overhead per i puntatori può essere rilevante.
  
 +
APP: utile per i log, dato l'accesso efficiente in append mode. Usata in Xerox alto, DEC TOPS-10
  
  
 +
Nell'allocazione indicizzata l'elenco dei blocchi che compongono un file viene memorizzato in un'area indice, quindi per accedere ad un file si carica in memoria la sua area indice e si utilizzano i puntatori contenuti.
  
−
a) #Quindi i valori possibili sono → (11, 12, 13, 14)
+
PRO: risolve frammentazione esterna; efficiente per accesso diretto. Il blocco indice viene caricato in memoria solo quando il file è aperto.
−
b) #
 
  
 +
CON: la dimensinoe del blocco indice determina ampiezza massima file
  
 +
APP: file grosse dimensioni in quanto e' facile accedere alla parte intermedia del file. Utile per i file system di uso generale.
  
 +
<h2> Esercizio c.2 </h2>
 +
<syntaxhighlight lang="C">
  
 +
#Casi possibili delle iterazioni
 +
int val = 0
  
 +
PQPQQ (((val +1) *2) +1) * 2 * 2 → 12
 +
PQQPQ (( val +1 ) * 2 * 2) +1 * 2 → 12
 +
QQPQP (((val * 2 * 2) + 1 )* 2) + 1 → 3
 +
QPQQP (((val * 2) + 1) * 2 * 2) + 1 → 5
 +
QPQPQ ((((val * 2) + 1) * 2) + 1) * 2 → 6
 +
 +
a) #Quindi i valori possibili sono → (3, 5, 6, 12)
 +
b) #
  
 
</syntaxhighlight>
 
</syntaxhighlight>
 +
- Midolo e Marangoni

Latest revision as of 17:02, 7 July 2017

Testo del compito

Esercizio c.1 

monitor nvie
{
	condition oktoread;
	queue buffer[N]; 
 
 
	procedure entry put(int n, generic object)
	{
		
                           if (buffer[n].length < NELEM)
				buffer[n].enqueue(object);
 
		           oktoread.signal();
 
	}
 
	procedure entry generic get(generic *object)
	{

               int count=0;

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

Save



Esercizio g.1

[soluzione]

Esercizio g.1 

  P1 2 2 2 2 2
  P2 3 2 3 2 3
  P3 1 2 1 2 1

NON-PREEMPTIVE 

  CPU |1|1|2|2|2|1|1|2|2|2|1|1|2|2|2|3| | |3| | |3|
  RQ  |2|2|1|1|1|2|2|1|1|1|2|2|3|3|3| | | | | | | |
      |3|3|3|3|3|3|3|3|3|3|3|3| | | | | | | | | | |
  IO1 | | |1|1| | | |1|1| | | | | | | | | | | | | |
  IO2 | | | | | |2|2| | | |2|2| | | | | | | | | | |           
  IO3 | | | | | | | | | | | | | | | | |3|3| |3|3| |

PREEMPTIVE 

  CPU |1|1|2|2|1|1|2|3|1|1|2|2|2|3|2|2|2|3|
  RQ  |2|2| | |2|2| | | |2|3|3|3| | | |3| |
      |3|3|3|3|3|3|3| | | | | | | | | | | |
  IO1 | | |1|1| | |1|1| | | | | | | | | | |
  IO2 | | | | | | | |2|2| | | | |2|2| | | |
  IO3 | | | | | | | | |3|3| | | | |3|3| | |

Esercizio g.2

a) quali sono le differenze fra la paginazione e la segmentazione nella gestione della memoria?

PAGINAZIONE Dimensioni pagina fissa; suddivisione automatica; le pagine possono contenere informazioni disomogenee (codice, dati); una pagina ha un indirizzo; dim tipiche: 1-4KB

SEGMENTAZIONE Dimensioni variabili; la suddivisione in segmenti e' compito del programmatore; i segmenti contengono dati omogenei; un segmento ha un nome; dim tipica: 64KB-1MB


b) quali sono le differenze fra le operazioni P e V dei semafori e le operazioni wait/signal delle variabili di condizione?

Signal() non ha alcun effetto se nessun processo sta attendendo la condizione. V memorizza il verificarsi degli eventi. Wait() e' sempre bloccante. P, se il semaforo ha valore positivo, no. Il processo risvegliato dalla signal viene eseguito per primo.


c) allocazione contigua, concatenata e indicizzata nei file system, quali sono le differenze e i campi di applicazione?

Nell'allocazione contigua ogni file viene allocato in blocchi di memoria adiacenti.

PRO: non sono presenti strutture di collegamento, l'accesso sequenziale è efficiente. Anche l'accesso diretto risulta efficiente.

CON: frammentazione esterna, politica scelta blocchi liberi da usare; i file non possono crescere

APP: e'utilizzato nell'ISO 9660 (dischi ottici) e nel file system NTFS.


Nell'allocazione concatenata ogni file è una lista concatenata di blocchi ed ogni blocco contiene un puntatore al blocco successivo.

PRO: accesso sequenziale o in append mode efficiente, risolve la frammentazione esterna

CON: l'accesso diretto è inefficiente, se il blocco è piccolo l'overhead per i puntatori può essere rilevante.

APP: utile per i log, dato l'accesso efficiente in append mode. Usata in Xerox alto, DEC TOPS-10


Nell'allocazione indicizzata l'elenco dei blocchi che compongono un file viene memorizzato in un'area indice, quindi per accedere ad un file si carica in memoria la sua area indice e si utilizzano i puntatori contenuti.

PRO: risolve frammentazione esterna; efficiente per accesso diretto. Il blocco indice viene caricato in memoria solo quando il file è aperto.

CON: la dimensinoe del blocco indice determina ampiezza massima file

APP: file grosse dimensioni in quanto e' facile accedere alla parte intermedia del file. Utile per i file system di uso generale.

Esercizio c.2 

#Casi possibili delle iterazioni
int val = 0

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

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

- Midolo e Marangoni

Retrieved from "https://so.v2.cs.unibo.it/wiki/index.php?title=Prova_Teorica_2013.06.21&oldid=1954"