Sistemi Operativi - User contributions [en]

ProvaPratica 2009.09.23

2014-04-30T13:59:34Z

Mirk M: Created page with "<h1>http://www.cs.unibo.it/~renzo/so/pratiche/2009.09.23.pdf</h1> == Esercizio 1 == <syntaxhighlight lang="C"> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #in..."

<h1>http://www.cs.unibo.it/~renzo/so/pratiche/2009.09.23.pdf</h1>

== Esercizio 1 ==

<syntaxhighlight lang="C">
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>

#define BUFSIZE 4096

void buf_invert(char *b_input, char *b_output)
{
int i;

for(i=0; i<BUFSIZE; i++)
{
if(b_input[i] == EOF)
break;
b_output[i] = b_input[BUFSIZE-i];
}
}

off_t file_dim(char *path)
{
struct stat buf;
int ris;

ris = stat (path, &buf);
if(ris == -1)
{
printf("Stat, error %d: %s\n", errno, strerror(errno));
return -1;
}

return buf.st_size;
}

int invert(int input, int output, off_t file_size)
{
char b_input[BUFSIZE], b_output[BUFSIZE];
int rris, wris;
off_t i=0;

while(i < file_size)
{
rris = pread(input, b_input, BUFSIZE, i);
if(rris == -1)
{
printf("Pread error %d: %s\n", errno, strerror(errno));
return -1;
}

i += rris;

wris = pwrite(output, b_output, BUFSIZE, file_size-i);
if(wris == -1)
{
printf("Pwrite error %d: %s\n", errno, strerror(errno));
return -1;
}

if(rris != wris)
{
printf("Invert error\n");
return -1;
}

}

return 0;
}

int main(int argc, char *argv[])
{
int input, output, ris;
off_t file_size;

if(argc > 3)
{
printf("Too many arguments\n");
return -1;
}

input = open(argv[1], O_RDONLY);
if(input == -1)
{
printf("Open error %d: %s\n", errno, strerror(errno));
return -1;
}

file_size = file_dim(argv[1]);
if(file_size == -1)
{
printf("File_dim error\n");
return -1;
}

printf("File size %d\n", file_size);

output = open(argv[2], O_CREAT | O_RDWR /*| O_APPEND*/);
if(output == -1)
{
printf("File creation (open) error %d: %s\n", errno, strerror(errno));
return -1;
}

ris = invert(input, output, file_size);
if(ris == -1)
{
printf("Invert error\n");
return -1;
}

return 0;
}
</syntaxhighlight>

Mirko_M

Main Page

2014-04-30T13:54:37Z

Mirk M:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizi a caso del Prof.]]

[[Decalogo di Programmazione Concorrente]]

[[Python Programma tieni punteggio.]]

[[Comandi visti alle lezioni.]]

[[SYS CALL viste a lezione.]]

[[Parametri con getopt().]]

[[Funzione con numero variabile di parametri.]]

[[stampf - implementazione ridotta della printf.]]

[[Producer&Consumer MP.]]

[[ProvaPratica 2014.01.23]]

[[ProvaPratica 2013.09.13]]

[[ProvaPratica 2013.07.18]]

[[ProvaPratica 2013.06.21]]

[[ProvaPratica 2013.05.29]]

[[ProvaPratica 2013.02.15]]

[[ProvaPratica 2013.01.25]]

[[ProvaPratica 2012.09.19]]

[[ProvaPratica 2005.02.10]]

[[ProvaTeoria_2011.07.25]]

[[ProvaTeorica_2012.02.09]]

[[ProvaTeorica_2012.05.24]]

[[ProvaTeorica_2012.06.15]]

[[ProvaTeorica_2012.09.18]]

[[ProvaTeorica_2013.05.30]]

[[ProvaTeorica_2011.02.11]]

[[ProvaTeorica 2013.07.19]]

[[ProvaTeorica 2013.01.24]]

[[ProvaTeorica 2014.01.22]]

[[ProvaTeorica 2012.07.16]]

[[ProvaPratica_2010.07.12]]

[[Prova Teorica 2008.01.16]]

[[Prova Teorica 2013.09.12]]

[[Prova Teorica 2009.09.18]]

[[Prova Teorica 2008.09.17]]

[[Prova Teorica 2007.09.07]]

[[Prova Teorica 2013.06.21]]

[[ProvaPratica 2010.02.03]]

[[ProvaPratica 2011.09.12]]

[[ProvaPratica 2009.02.12]]

[[ProvaPratica 2009.01.15]]

[[Prova Teorica 2007.07.12]]

[[ProvaTeoria 2011.01.17]]

[[ProvaTeoria 2010.05.12]]

[[ProvaTeoria 2012.01.12]]

[[ProvaPratica 2009.09.23]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

ProvaTeorica 2012.07.16

2014-03-30T20:48:22Z

Mirk M:

[http://www.cs.unibo.it/~renzo/so/compiti/2012-07-16.tot.pdf Link Testo]

<h2>Esercizio C.1</h2>

Mia Soluzione:
<syntaxhighlight lang="C">
#define RED 0
#define BLUE 1
//restituisce 1 se c'e piu del 75% blue o 75% di red
//restituisce 0 se non c'e una maggiornza
int media(color){
int mediared;
int localinto = into;
if (color != NULL){
localinto[color]++;
}
mediared = ((100*localinto[0])/(localinto[0]+localinto[1]));
if(mediared >=75 || mediared < 25){
return 1;//75% di rossi o di blue
}else{
return 0;// non c'e maggioranza
}
}

monitor limcol{

conditon oktoenter[2];
int into[2];

enter(color){
if(media(color) != 1){// attendo perche' non c'e una maggioranza
oktoenter[color].wait();
}
into[color]++;
}

exit(color){
into[color]--;
if(media(1-color) == 1){
oktoenter[1-color].signal();
}else if(media(color) == 1){
oktoenter[color].signal();
}
}
}
</syntaxhighlight>
- Midolo

<syntaxhighlight lang="C">
#define ROSSO 0
#define BLU 1

monitor limcol {
condition oktoenter
condition oktoexit
int running[2] // numero di processi rossi [0] e blu [1] in esecuzione
queue waiting /* coda delle coppie (colore,azione) dei processi in attesa di entrare (azione==1)
o uscire (azione==-1) */

/* restituisce true se aggiungendo o rimuovendo (in base a i) un processo del colore passato
viene rispettato il 75% dei processi di un colore */
bool morethan75p(colore, int i) {
return (running[colore]+i>=running[1-colore]*3 || (running[colore]+i)*3<=running[1-colore])
}

// risveglia il processo in testa alla coda waiting se è possibile farlo
void checkwakeup() {
if (waiting.empty() == false) {
colore,azione = waiting.head() // head resituisce l'elemento in testa senza rimuoverlo
if (morethan75p(colore,azione)) {
waiting.dequeue()
if (azione == 1)
oktoenter.signal()
else
oktoexit.signal()
}
}
}

procedure entry enter(colore) {
if (morethan75p(colore,1)==false) {
waiting.enqueue(colore,1)
oktoenter.wait()
}
running[colore]++
checkwakeup()
}

procedure entry exit(colore) {
if (morethan75p(colore,-1)==false) {
waiting.enqueue(colore,-1)
oktoexit.wait()
}
running[colore]--
checkwakeup()
}
}
</syntaxhighlight>
Daniele Cortesi

<syntaxhighlight lang="C">
define RED 0
define BLUE 1
int majorcolor = -1
int numproc[2] = 0,0
cond oktoenter[2] //bastavano due condizioni.
cond oktoexit[2]

monitor limcol{
procedure entry enter(COL){
if(COL == majorcolor){
numproc[COL]++
if(((proc[majorcolor])*100/(numproc[COL] + numproc[1-COL] + 1)) >= 75)
oktoenter[1-COL].signal()
}
else if(COL == 1-majorcolor){
if((proc[majorcolor]*100/(numproc[COL] + numproc[1-COL] + 1)) < 75)
oktoenter[COL].wait()
if(majorcolor == -1)
majorcolor == COL
numproc[COL]++
}
else{
numproc[COL]++
majorcolor = COL
}
}

procedure entry exit(COL){
if(numproc[COL] + numproc[1-COL] == 1){
majorcolor = -1
numproc[COL]--
oktoenter[1-COL].signal()
}
else if(COL == majorcolor){
if(((proc[majorcolor] - 1)*100/(numproc[COL] + numproc[1-COL] - 1)) < 75){
oktoexit[COL].wait()
numproc[COL]--
}
}
else if(COL == 1-majorcolor){
numproc[COL]--
if(((proc[majorcolor])*100/(numproc[COL] + numproc[1-COL] - 1)) >= 75)
oktoexit[1-COL].signal()
}
}
}

</syntaxhighlight>
Fede

<syntaxhighlight lang="C">
define RED 0
define BLU 1

limcol{
/*variable*/
int array[2] = 0,0;
color major = -1;
/*condition*/
condition oktoenter[2];
condition oktoleave[2];

procedure entry enter( color ){
if ( majorcolor == -1 )
majorcolor = color;
if ( majorcolor == (1-color) && newmajorcolor%(color) < 75% )
oktoenter[color].wait();
array[color]++;
if ( majorcolor == -1 ) //se un processo si risveglia nel monitor vuoto deve impostare majorcolor
majorcolor = color;
if ( newmajorcolor%(1-color) >= 75% )
oktoenter[1-color].signal();
}

procedure entry exit( color ){
if ( majorcolor == color && majorcolor_less1%(color) > 75% )
oktoleave[color].wait();
array[color]--;
if ( !colorsempty() )
if ( majorcolor_less1%(color) >= 75% )
oktoleave[1-color].signal();
else{
majorcolor == -1;
oktoenter[1-color].signal();
}
}

/*
newmajorcolor%(color) calcola la nuova % del colore maggiore aggiungendo color
majorcolor_less1%(color) calcola la nuova % del colore maggiore togliendo color
*/
</syntaxhighlight>
Pir@t@

<syntaxhighlight lang="C">
#DEFINE BLUE 0
#DEFINE RED 1
monitor limcol{
condition ok;
int numcolor[2];
Queue q;
int i=1;
procedure entry enter(color){
if((numcolor[color] + 1 < float((tot+1)*(75/100)) &&
numcolor[color] + 1 >= float((tot+1)*(25/100))) ||
!q.empty() )
{
q.enqueue(color);
ok.wait();
i++;
if(!q.empty()){
if(numcolor[q.head()] + i >= float((tot+i)*(75/100)) ||
numcolor[q.head()] + i < float((tot+i)*(25/100))) )
{
q.dequeue();
ok.signal();
}
i=1;
}
}
numcolor[color]++;
tot++;
}
procedure entry exit(color){
numcolor[color]--;
tot--;
if( numcolor[q.head()] + 1 >= float((tot+1)*(75/100)) ||
numcolor[q.head()] + 1 < float((tot+1)*(25/100)) )
{
q.dequeue();
ok.signal();
}
}
</syntaxhighlight>
Alessandro

<syntaxhighlight lang="C">
#define LIMIT 0.75
#define RED 0
#define BLUE 1

monitor limcol{
double procNum; // numero processi all'interno del semaforo
double pColourNum[2]; // numero di processi rossi [0] o blu [1]
condition okToEnter;
condition okToLeave;

procedure entry enter(colour)
{ // Se ci sono processi nel semaforo && il numero dei processi del colore attuale è inferiore
// al 75% && il numero dei processi dell'altro colore è inferiore al 75% sul totale+1, wait
if(procNum != 0 && (pColourNum[1-colour]/procNum+1) < LIMIT && (pColourNum[colour]/procNum) < LIMIT)
{
okToEnter.wait();
}

else
{
procNum++;
pColourNum[colour]++;

// Se qualcuno è in attesa di uscire e adesso le percentuali lo permettono, signal
if((pColourNum[colour]/procNum-1) >= LIMIT)
{
okToLeave.signal();
}

// Se qualcuno è in attesa di entrare e adesso le percentuali lo permettono, signal
if((pColourNum[colour]/procNum+1) >= LIMIT)
{
okToEnter.signal();
}
}
}

procedure entry exit(colour)
{
// Se il numero di processi del colore attuale è inferiore al 75% sul totale+1, wait
if((pColourNum[colour]/procNum-1) < LIMIT)
{
okToLeave.wait();
}

else
{
procNum--;
pColourNum[colour]--;

// Se qualcuno dell'altro colore è in attesa di uscire e adesso le percentuali lo permettono, signal
if((pColourNum[1-colour]/procNum-1) >= LIMIT)
{
okToLeave.signal();
}

}
}

limcol
{
procNum = 0;
pColourNum[0] = 0;
pColourNum[1] = 0;
}
}
</syntaxhighlight>
Mirko

==Esercizio c.2==
Per quali indici n le funzioni foo possono essere utilizzate al posto della test&set?

Risposta: per n = 5

Nella Test&Set x prende il valore di y, quindi y deve essere = booln(x,y)
Andiamo a vedere per quali valori y è uguale a booln(x,y)
{| border="1" class="wikitable"
|-
! x || y || bool0 || bool1 || bool2 || bool3 || bool4 || bool5 || bool6 || bool7 || bool8 || bool9 || bool10 || bool11 || bool12 || bool13 || bool14 || bool15
|-
| 0 || '''0''' || '''0''' || '''0''' || '''0''' || '''0''' || '''0''' || '''0''' || '''0''' || '''0''' || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1
|-
| 0 || '''1''' || 0 || 0 || 0 || 0 || '''1''' || '''1''' || '''1''' || '''1''' || 0 || 0 || 0 || 0 || '''1''' || '''1''' || '''1''' || '''1'''
|-
| 1 || '''0''' || '''0''' || '''0''' || 1 || 1 || '''0''' || '''0''' || 1 || 1 || '''0''' || '''0''' || 1 || 1 || '''0''' || '''0''' || 1 || 1
|-
| 1 || '''1''' || 0 || '''1''' || 0 || '''1''' || 0 || '''1''' || 0 || '''1''' || 0 || '''1''' || 0 || '''1''' || 0 || '''1''' || 0 || '''1'''
|-
|}

In bold sono indicati i valori per cui y = booln(x,y)
L'unico caso in cui i valori sono evidenziati in ogni riga è per bool5.

Giulia (non sono molto sicura della soluzione, ma questo è il ragionamento che mi è sembrato più corretto)

==Esercizio g.1==
{| border="1" class="wikitable"
|-
! Reference String
| 1 || 2 || 3 || 4 || 5 || 6 || 4 || 5 || 6 || 3 || 2 || 1 || 3 || 2 || 1 || 6 || 5 || 4 || 6 || 5 || 4 || 1 || 2 || 3
|-
! Page Frame 1
| 1 || 1 || 1 || 4 || 4 || 4 || || || || 3 || 3 || 3 || || || || 6 || 6 || 6 || || || || 1 || 1 || 1
|-
! Page Frame 2
| || 2 || 2 || 2 || 5 || 5 || || || || 5 || 2 || 2 || || || || 2 || 5 || 5 || || || || 5 || 2 || 2
|-
! Page Frame 3
| || || 3 || 3 || 3 || 6 || || || || 6 || 6 || 1 || || || || 1 || 1 || 4 || || || || 4 || 4 || 3
|}

The above Reference String is both FIFO, LRU and MIN compliant.

-TomOgn

ProvaTeorica 2012.07.16

2014-03-30T20:47:03Z

Mirk M:

[http://www.cs.unibo.it/~renzo/so/compiti/2012-07-16.tot.pdf Link Testo]

<h2>Esercizio C.1</h2>

Mia Soluzione:
<syntaxhighlight lang="C">
#define RED 0
#define BLUE 1
//restituisce 1 se c'e piu del 75% blue o 75% di red
//restituisce 0 se non c'e una maggiornza
int media(color){
int mediared;
int localinto = into;
if (color != NULL){
localinto[color]++;
}
mediared = ((100*localinto[0])/(localinto[0]+localinto[1]));
if(mediared >=75 || mediared < 25){
return 1;//75% di rossi o di blue
}else{
return 0;// non c'e maggioranza
}
}

monitor limcol{

conditon oktoenter[2];
int into[2];

enter(color){
if(media(color) != 1){// attendo perche' non c'e una maggioranza
oktoenter[color].wait();
}
into[color]++;
}

exit(color){
into[color]--;
if(media(1-color) == 1){
oktoenter[1-color].signal();
}else if(media(color) == 1){
oktoenter[color].signal();
}
}
}
</syntaxhighlight>
- Midolo

<syntaxhighlight lang="C">
#define ROSSO 0
#define BLU 1

monitor limcol {
condition oktoenter
condition oktoexit
int running[2] // numero di processi rossi [0] e blu [1] in esecuzione
queue waiting /* coda delle coppie (colore,azione) dei processi in attesa di entrare (azione==1)
o uscire (azione==-1) */

/* restituisce true se aggiungendo o rimuovendo (in base a i) un processo del colore passato
viene rispettato il 75% dei processi di un colore */
bool morethan75p(colore, int i) {
return (running[colore]+i>=running[1-colore]*3 || (running[colore]+i)*3<=running[1-colore])
}

// risveglia il processo in testa alla coda waiting se è possibile farlo
void checkwakeup() {
if (waiting.empty() == false) {
colore,azione = waiting.head() // head resituisce l'elemento in testa senza rimuoverlo
if (morethan75p(colore,azione)) {
waiting.dequeue()
if (azione == 1)
oktoenter.signal()
else
oktoexit.signal()
}
}
}

procedure entry enter(colore) {
if (morethan75p(colore,1)==false) {
waiting.enqueue(colore,1)
oktoenter.wait()
}
running[colore]++
checkwakeup()
}

procedure entry exit(colore) {
if (morethan75p(colore,-1)==false) {
waiting.enqueue(colore,-1)
oktoexit.wait()
}
running[colore]--
checkwakeup()
}
}
</syntaxhighlight>
Daniele Cortesi

<syntaxhighlight lang="C">
define RED 0
define BLUE 1
int majorcolor = -1
int numproc[2] = 0,0
cond oktoenter[2] //bastavano due condizioni.
cond oktoexit[2]

monitor limcol{
procedure entry enter(COL){
if(COL == majorcolor){
numproc[COL]++
if(((proc[majorcolor])*100/(numproc[COL] + numproc[1-COL] + 1)) >= 75)
oktoenter[1-COL].signal()
}
else if(COL == 1-majorcolor){
if((proc[majorcolor]*100/(numproc[COL] + numproc[1-COL] + 1)) < 75)
oktoenter[COL].wait()
if(majorcolor == -1)
majorcolor == COL
numproc[COL]++
}
else{
numproc[COL]++
majorcolor = COL
}
}

procedure entry exit(COL){
if(numproc[COL] + numproc[1-COL] == 1){
majorcolor = -1
numproc[COL]--
oktoenter[1-COL].signal()
}
else if(COL == majorcolor){
if(((proc[majorcolor] - 1)*100/(numproc[COL] + numproc[1-COL] - 1)) < 75){
oktoexit[COL].wait()
numproc[COL]--
}
}
else if(COL == 1-majorcolor){
numproc[COL]--
if(((proc[majorcolor])*100/(numproc[COL] + numproc[1-COL] - 1)) >= 75)
oktoexit[1-COL].signal()
}
}
}

</syntaxhighlight>
Fede

<syntaxhighlight lang="C">
define RED 0
define BLU 1

limcol{
/*variable*/
int array[2] = 0,0;
color major = -1;
/*condition*/
condition oktoenter[2];
condition oktoleave[2];

procedure entry enter( color ){
if ( majorcolor == -1 )
majorcolor = color;
if ( majorcolor == (1-color) && newmajorcolor%(color) < 75% )
oktoenter[color].wait();
array[color]++;
if ( majorcolor == -1 ) //se un processo si risveglia nel monitor vuoto deve impostare majorcolor
majorcolor = color;
if ( newmajorcolor%(1-color) >= 75% )
oktoenter[1-color].signal();
}

procedure entry exit( color ){
if ( majorcolor == color && majorcolor_less1%(color) > 75% )
oktoleave[color].wait();
array[color]--;
if ( !colorsempty() )
if ( majorcolor_less1%(color) >= 75% )
oktoleave[1-color].signal();
else{
majorcolor == -1;
oktoenter[1-color].signal();
}
}

/*
newmajorcolor%(color) calcola la nuova % del colore maggiore aggiungendo color
majorcolor_less1%(color) calcola la nuova % del colore maggiore togliendo color
*/
</syntaxhighlight>
Pir@t@

<syntaxhighlight lang="C">
#DEFINE BLUE 0
#DEFINE RED 1
monitor limcol{
condition ok;
int numcolor[2];
Queue q;
int i=1;
procedure entry enter(color){
if((numcolor[color] + 1 < float((tot+1)*(75/100)) &&
numcolor[color] + 1 >= float((tot+1)*(25/100))) ||
!q.empty() )
{
q.enqueue(color);
ok.wait();
i++;
if(!q.empty()){
if(numcolor[q.head()] + i >= float((tot+i)*(75/100)) ||
numcolor[q.head()] + i < float((tot+i)*(25/100))) )
{
q.dequeue();
ok.signal();
}
i=1;
}
}
numcolor[color]++;
tot++;
}
procedure entry exit(color){
numcolor[color]--;
tot--;
if( numcolor[q.head()] + 1 >= float((tot+1)*(75/100)) ||
numcolor[q.head()] + 1 < float((tot+1)*(25/100)) )
{
q.dequeue();
ok.signal();
}
}
</syntaxhighlight>
Alessandro

<syntaxhighlight lang="C">
#define LIMIT 0.75
#define RED 0
#define BLUE 1

monitor limcol{
double procNum; // numero processi all'interno del semaforo
double pColourNum[2]; // numero di processi rossi [0] o blu [1]
condition okToEnter;
condition okToLeave;

procedure entry enter(colour)
{ // Se ci sono processi nel semaforo && il numero dei processi del colore attuale è inferiore
// al 75% && il numero dei processi dell'altro colore è inferiore al 75% sul totale+1, wait
if(procNum != 0 && (pColourNum[1-colour]/procNum+1) < LIMIT && (pColourNum[colour]/procNum) < LIMIT)
{
okToEnter.wait();
}

else
{
procNum++;
pColourNum[colour]++;

// Se qualcuno è in attesa di uscire e adesso le percentuali lo permettono, signal
if((pColourNum[colour]/procNum-1) >= LIMIT)
{
okToLeave.signal();
}

// Se qualcuno è in attesa di entrare e adesso le percentuali lo permettono, signal
if((pColourNum[colour]/procNum+1) >= LIMIT)
{
okToEnter.signal();
}
}
}

procedure entry exit(colour)
{
// Se il numero di processi del colore attuale è inferiore al 75% sul totale+1, wait
if((pColourNum[colour]/procNum-1) < LIMIT)
{
okToLeave.wait();
}

else
{
procNum--;
pColourNum[colour]--;

// Se qualcuno dell'altro colore è in attesa di uscire e adesso le percentuali lo permettono, signal
if((pColourNum[1-colour]/procNum-1) >= LIMIT)
{
okToLeave.signal();
}

}
}

limcol
{
procNum = 0;
redProc = 0;
blueProc = 0;
}
}
</syntaxhighlight>
Mirko

==Esercizio c.2==
Per quali indici n le funzioni foo possono essere utilizzate al posto della test&set?

Risposta: per n = 5

Nella Test&Set x prende il valore di y, quindi y deve essere = booln(x,y)
Andiamo a vedere per quali valori y è uguale a booln(x,y)
{| border="1" class="wikitable"
|-
! x || y || bool0 || bool1 || bool2 || bool3 || bool4 || bool5 || bool6 || bool7 || bool8 || bool9 || bool10 || bool11 || bool12 || bool13 || bool14 || bool15
|-
| 0 || '''0''' || '''0''' || '''0''' || '''0''' || '''0''' || '''0''' || '''0''' || '''0''' || '''0''' || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1
|-
| 0 || '''1''' || 0 || 0 || 0 || 0 || '''1''' || '''1''' || '''1''' || '''1''' || 0 || 0 || 0 || 0 || '''1''' || '''1''' || '''1''' || '''1'''
|-
| 1 || '''0''' || '''0''' || '''0''' || 1 || 1 || '''0''' || '''0''' || 1 || 1 || '''0''' || '''0''' || 1 || 1 || '''0''' || '''0''' || 1 || 1
|-
| 1 || '''1''' || 0 || '''1''' || 0 || '''1''' || 0 || '''1''' || 0 || '''1''' || 0 || '''1''' || 0 || '''1''' || 0 || '''1''' || 0 || '''1'''
|-
|}

In bold sono indicati i valori per cui y = booln(x,y)
L'unico caso in cui i valori sono evidenziati in ogni riga è per bool5.

Giulia (non sono molto sicura della soluzione, ma questo è il ragionamento che mi è sembrato più corretto)

==Esercizio g.1==
{| border="1" class="wikitable"
|-
! Reference String
| 1 || 2 || 3 || 4 || 5 || 6 || 4 || 5 || 6 || 3 || 2 || 1 || 3 || 2 || 1 || 6 || 5 || 4 || 6 || 5 || 4 || 1 || 2 || 3
|-
! Page Frame 1
| 1 || 1 || 1 || 4 || 4 || 4 || || || || 3 || 3 || 3 || || || || 6 || 6 || 6 || || || || 1 || 1 || 1
|-
! Page Frame 2
| || 2 || 2 || 2 || 5 || 5 || || || || 5 || 2 || 2 || || || || 2 || 5 || 5 || || || || 5 || 2 || 2
|-
! Page Frame 3
| || || 3 || 3 || 3 || 6 || || || || 6 || 6 || 1 || || || || 1 || 1 || 4 || || || || 4 || 4 || 3
|}

The above Reference String is both FIFO, LRU and MIN compliant.

-TomOgn