Sistemi Operativi - User contributions [en]

Prova teorica 2017.05.29

2017-06-16T16:25:11Z

Stefano.zaniboni: /* Soluzione di Save */

[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 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

<syntaxhighlight lang="C">
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;
}}

</syntaxhighlight>
Secondo devi utilizzare il nome corretto per le procedure entry, cioè mancano nuovapartita e allabandiera, che non hai definito. Con i corretti parametri. --[[User:FedericoB|FedericoB]] ([[User talk:FedericoB|talk]]) 18:45, 15 June 2017 (CEST)
===Soluzione di Stefano Zaniboni===

<syntaxhighlight lang="C">
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()
}
}

</syntaxhighlight>

==Esercizio c.2==

===Soluzione di Stefano Zaniboni===
<syntaxhighlight lang="C">
/*
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})
}
}
}

</syntaxhighlight>

==Esercizio g.1==
===Soluzione di GiovanniF===

min = lifo 1234123124123124...

lifo = lru 123124123124123124...

--[[User:FedericoB|FedericoB]] ([[User talk: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

<pre>
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
# # # # #
</pre>

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

<pre>
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
# # # #
</pre>

==Esercizio g.2==
#'''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è?)
#'''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.
#'''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ì?
#'''Perchè revocare un'autorizzazione espressa come capability è più difficile che revocare lo stesso diritto quando espresso come access control list?'''

Prova teorica 2017.05.29

2017-06-16T09:48:57Z

Stefano.zaniboni: /* Soluzione di Stefano Zaniboni */

[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 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

<syntaxhighlight lang="C">
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;
}}

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

==Esercizio c.2==

===Soluzione di Stefano Zaniboni===
<syntaxhighlight lang="C">
/*
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})
}
}
}

</syntaxhighlight>

==Esercizio g.1==
===Soluzione di GiovanniF===

min = lifo 1234123124123124...

lifo = lru 123124123124123124...

--[[User:FedericoB|FedericoB]] ([[User talk: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

<pre>
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
# # # # #
</pre>

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

<pre>
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
# # # #
</pre>

==Esercizio g.2==
#'''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è?)
#'''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.
#'''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ì?
#'''Perchè revocare un'autorizzazione espressa come capability è più difficile che revocare lo stesso diritto quando espresso come access control list?'''

Prova teorica 2017.05.29

2017-06-16T09:47:46Z

Stefano.zaniboni: /* Soluzione di Stefano Zaniboni */

[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 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

<syntaxhighlight lang="C">
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;
}}

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

==Esercizio c.2==

===Soluzione di Stefano Zaniboni===
<syntaxhighlight lang="C">
/*
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{
set_proc_lost_and_found(getpid())
while(true){
{snd, dst, m} = dmsgrecv()
if dst != getpid(){
asend(dst, {snd, dst, m})
}
}
}

</syntaxhighlight>

==Esercizio g.1==
===Soluzione di GiovanniF===

min = lifo 1234123124123124...

lifo = lru 123124123124123124...

--[[User:FedericoB|FedericoB]] ([[User talk: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

<pre>
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
# # # # #
</pre>

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

<pre>
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
# # # #
</pre>

==Esercizio g.2==
#'''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è?)
#'''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.
#'''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ì?
#'''Perchè revocare un'autorizzazione espressa come capability è più difficile che revocare lo stesso diritto quando espresso come access control list?'''

Prova teorica 2017.05.29

2017-06-16T09:47:04Z

Stefano.zaniboni: /* Esercizio c.2 */

[http://www.cs.unibo.it/~renzo/so/compiti/2017.05.29.tot.pdf 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

<syntaxhighlight lang="C">
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;
}}

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

==Esercizio c.2==

===Soluzione di Stefano Zaniboni===
<syntaxhighlight lang="C">
/*
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{
set_proc_lost_and_found(getpid())
while(true){
{snd, dst, m} = dmsgrecv()
if dst != getpid(){
asend(dst, {snd, dst, m})
}
}
}

</syntaxhighlight>

==Esercizio g.1==
===Soluzione di GiovanniF===

min = lifo 1234123124123124...

lifo = lru 123124123124123124...

--[[User:FedericoB|FedericoB]] ([[User talk: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

<pre>
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
# # # # #
</pre>

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

<pre>
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
# # # #
</pre>

==Esercizio g.2==
#'''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è?)
#'''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.
#'''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ì?
#'''Perchè revocare un'autorizzazione espressa come capability è più difficile che revocare lo stesso diritto quando espresso come access control list?'''

Prova Teorica 16-07-2014

2015-05-19T13:31:57Z

Stefano.zaniboni:

<source lang="text">
scrivere il monitor mMbb che realizzi un meccanismo di un minmax bounded buffer.
Dopo le prime MIN operazioni di scrittura, un minmax bounded buffer deve sempre avere almeno MIN elementi e mai piu' di MAX
elementi (e' quindi limitato sia nell'ampiezza massima, sia nell'ampiezza minima).
Le funzioni (procedure entry) read e write del minmax bounded buffer hanno gli stessi argomenti e valori di ritorno di quelle del producer/consumer o del bounded buffer ordinario.
</source>
===Soluzione di Stefano Zaniboni===
<source lang="c">
/*esercizio 1*/

monitor mMbb{
object[] buffer; //spazio di memorizzazione

final int MAXELEM; // numero massimo di elementi che ci possono essere nel buffer
final int MINELEM; //numero minimo di elementi --> numero di scritture minime

condition okW; // dove mi fermo se non posso scrivere
condition okR; // dove mi fermo se non posso leggere

int count; // elementi presenti nel buffer
int front; // contatore al elemento prodotto
int rear; // contatore al elemento consumato

mMbb(){
buffer = new Object[MAXELEM];
count = rear = front = 0;
}

procedure entry object read(){
if ((count < MINELEM)) //se il buffer e' pieno oppure non ci sono min elem chiamo la wait
okR.wait();
eltype val = buffer[rear]; // assegno al val l'elemento che ho letto e poi aggiorno rear
rear = ((rear + 1) % (MAXELEM -1 )); // aggiorno rear;
count--; // decremento count per dire che ho consumato un elemento
okW.signal(); // qui faccio signal sui produttori che adesso possono scrivere
return retval;
}
procedure entry void write(int val){
if (count == buffer.length) //se il buffer e' pieno mi fermo
okW.wait();
buffer[front] = val; //scrivo elemento
count++; //aggiorno i prodotti disponibili
front = ((front+1)%(MAXELEM - 1)); // aggiorno il contatore front a puntare nella prossima posizione

okR.signal();
}

}
</source>

Prova Teorica 16-07-2014

2015-05-19T06:08:10Z

Stefano.zaniboni:

<source lang="text">
scrivere il monitor mMbb che realizzi un meccanismo di un minmax bounded buffer.
Dopo le prime MIN operazioni di scrittura, un minmax bounded buffer deve sempre avere almeno MIN elementi e mai piu' di MAX
elementi (e' quindi limitato sia nell'ampiezza massima, sia nell'ampiezza minima).
Le funzioni (procedure entry) read e write del minmax bounded buffer hanno gli stessi argomenti e valori di ritorno di quelle del producer/consumer o del bounded buffer ordinario.
</source>
===Soluzione di Stefano Zaniboni===
<source lang="c">
/*esercizio 1*/

monitor mMbb{
object[] buffer; //spazio di memorizzazione

final int MAXELEM; // numero massimo di elementi che ci possono essere nel buffer
final int MINELEM; //numero minimo di elementi --> numero di scritture minime

condition okW; // dove mi fermo se non posso scrivere
condition okR; // dove mi fermo se non posso leggere

int count; // elementi presenti nel buffer
int front; // contatore al elemento prodotto
int rear; // contatore al elemento consumato

mMbb(){
buffer = new Object[MAXELEM];
count = rear = front = 0;
}

procedure entry object read(){
if ((count < MINELEM) || (count == (MAXELEM -1)) //se il buffer e' pieno oppure non ci sono min elem chiamo la wait
okR.wait();
eltype val = buffer[rear]; // assegno al val l'elemento che ho letto e poi aggiorno rear
rear = ((rear + 1) % (MAXELEM -1 )); // aggiorno rear;
count--; // decremento count per dire che ho consumato un elemento
okW.signal(); // qui faccio signal sui produttori che adesso possono scrivere
return retval;
}
procedure entry void write(int val){
if (count == buffer.length) //se il buffer e' pieno mi fermo
okW.wait();
buffer[front] = val; //scrivo elemento
count++; //aggiorno i prodotti disponibili
front = ((front+1)%(MAXELEM - 1)); // aggiorno il contatore front a puntare nella prossima posizione
okR.signal();
}

}
</source>

Prova Teorica 16-07-2014

2015-05-18T16:04:42Z

Stefano.zaniboni:

<source lang="text">
scrivere il monitor mMbb che realizzi un meccanismo di un minmax bounded buffer.
Dopo le prime MIN operazioni di scrittura, un minmax bounded buffer deve sempre avere almeno MIN elementi e mai piu' di MAX
elementi (e' quindi limitato sia nell'ampiezza massima, sia nell'ampiezza minima).
Le funzioni (procedure entry) read e write del minmax bounded buffer hanno gli stessi argomenti e valori di ritorno di quelle del producer/consumer o del bounded buffer ordinario.
</source>
===Soluzione di Stefano Zaniboni===
<source lang="c">
/*esercizio 1*/

monitor mMbb{
object[] buffer; //spazio di memorizzazione

final int MAXELEM; // numero massimo di elementi che ci possono essere nel buffer
final int MINELEM; //numero minimo di elementi --> numero di scritture minime

condition okW; // dove mi fermo se non posso scrivere
condition okR; // dove mi fermo se non posso leggere

int count; // elementi presenti nel buffer
int front; // contatore al elemento prodotto
int rear; // contatore al elemento consumato

mMbb(){
buffer = new Object[MAXELEM];
count = rear = front = 0;
}

procedure entry object read(){
if ((count < MINELEM) || (count == (MAXELEM -1)) //se il buffer e' pieno oppure non ci sono min elem chiamo la wait
okR.wait();
eltype val = buffer[rear]; // assegno al val l'elemento che ho letto e poi aggiorno rear
rear = ((rear + 1) % (MAXELEM -1 )); // aggiorno rear;
count--; // decremento count per dire che ho consumato un elemento
okW.signal(); // qui faccio signal sui produttori che adesso possono scrivere
return retval;
}
procedure entry void write(int val){
if (count == buffer.length) //se il buffer e' pieno mi fermo
okW.wait();
buffer[front] = val; //scrivo elemento
count++; //aggiorno i prodotti disponibili
front = ((front+1)%(MAXELEM - 1)); // aggiorno il contatore front a puntare nella prossima posizione
okR.signal();
}

}
</source>

Prova Teorica 16-07-2014

2015-05-18T16:04:00Z

Stefano.zaniboni: Created page with "<source lang="text"> scrivere il monitor mMbb che realizzi un meccanismo di un minmax bounded buffer. Dopo le prime MIN operazioni di scrittura, un minmax bounded buffer deve ..."

<source lang="text">
scrivere il monitor mMbb che realizzi un meccanismo di un minmax bounded buffer.
Dopo le prime MIN operazioni di scrittura, un minmax bounded buffer deve sempre avere almeno MIN elementi e mai piu' di MAX
elementi (e' quindi limitato sia nell'ampiezza massima, sia nell'ampiezza minima).
Le funzioni (procedure entry) read e write del minmax bounded buffer hanno gli stessi argomenti e valori di ritorno di quelle del producer/consumer o del bounded buffer ordinario.
</source>

<source lang="c">
/*esercizio 1*/

monitor mMbb{
object[] buffer; //spazio di memorizzazione

final int MAXELEM; // numero massimo di elementi che ci possono essere nel buffer
final int MINELEM; //numero minimo di elementi --> numero di scritture minime

condition okW; // dove mi fermo se non posso scrivere
condition okR; // dove mi fermo se non posso leggere

int count; // elementi presenti nel buffer
int front; // contatore al elemento prodotto
int rear; // contatore al elemento consumato

mMbb(){
buffer = new Object[MAXELEM];
count = rear = front = 0;
}

procedure entry object read(){
if ((count < MINELEM) || (count == (MAXELEM -1)) //se il buffer e' pieno oppure non ci sono min elem chiamo la wait
okR.wait();
eltype val = buffer[rear]; // assegno al val l'elemento che ho letto e poi aggiorno rear
rear = ((rear + 1) % (MAXELEM -1 )); // aggiorno rear;
count--; // decremento count per dire che ho consumato un elemento
okW.signal(); // qui faccio signal sui produttori che adesso possono scrivere
return retval;
}
procedure entry void write(int val){
if (count == buffer.length) //se il buffer e' pieno mi fermo
okW.wait();
buffer[front] = val; //scrivo elemento
count++; //aggiorno i prodotti disponibili
front = ((front+1)%(MAXELEM - 1)); // aggiorno il contatore front a puntare nella prossima posizione
okR.signal();
}

}
</source>

Main Page

2015-05-18T16:02:56Z

Stefano.zaniboni:

Questo è il Wiki del Corso di Sistemi Operativi

[[Prova Teorica 16-07-2014]]

[[Prova Pratica 20-02-2014]]

[[Prova Pratica 02-07-2014]]

[[Buffer Limitato]]

[[Esercizio 1-2 Prova Pratica 30-05-2012]]

[[Esercizio 3 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 30-05-2012]]

[[Esercizio 1 Prova Pratica 23-06-09]]

[[Esercizio 1 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 20-06-2013]]

[[Esercizio 3 Prova Pratica 29-05-14]]

[[Esercizio 2 esame 29/05/2014]]

[[Grep piramidale (non tanto grep) esame 2.7.2003]]

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

[[Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)]]

[[Aggiorna cartelle (Prova pratica 23-01-2014)]]

[[Esercizio 3 prova pratica 29 maggio 2014]]

[[Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)]]

[[Esercizio 1 Prova Pratica 12-09-11]]

[[Esercizio 1 Prova Pratica 25-01-2013]]

[[Esercizio 3 Prova Pratica 22-06-2011]]

[[Esercizio 3, prova pratica, 18-07-2013]]

[[Esercizio 3, prova pratica, 17-07-2014]]

[[Esercizio 1, prova pratica, 23-01-2014]]

[[Prova pratica Esercizio 3 esami 17_07_12 - 17_06_14 - 19_07_10]]

[[Prova pratica 23_01_14]]

[[Albero binario 2002-07-23]]

[[50 Sfumature di Fibonacci]]

[[Esercizio 1 Prova Pratica 20/06/12]]

[[Esercizio 3 Prova Pratica 17/06/14]]

[[Esercizio 3, prova pratica 13/09/2013]]

[[Prova pratica 17 07 14]]

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Main Page

2015-05-12T19:43:14Z

Stefano.zaniboni:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizio 1-2 Prova Pratica 30-05-2012]]

[[Esercizio 3 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 30-05-2012]]

[[Esercizio 1 Prova Pratica 23-06-09]]

[[Esercizio 1 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 20-06-2013]]

[[Esercizio 3 Prova Pratica 29-05-14]]

[[Esercizio 2 esame 29/05/2014]]

[[Grep piramidale (non tanto grep) esame 2.7.2003]]

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

[[Linker fisico (Prova pratica 20-02-2014)]]

[[Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)]]

[[Aggiorna cartelle (Prova pratica 23-01-2014)]]

[[Esercizio 3 prova pratica 29 maggio 2014]]

[[Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)]]

[[Esercizio 1 Prova Pratica 12-09-11]]

[[Esercizio 1 Prova Pratica 25-01-2013]]

[[Esercizio 3 Prova Pratica 22-06-2011]]

[[Esercizio 3, prova pratica, 18-07-2013]]

[[Esercizio 3, prova pratica, 17-07-2014]]

[[Esercizio 1, prova pratica, 23-01-2014]]

[[Prova pratica Esercizio 3 esami 17_07_12 - 17_06_14 - 19_07_10]]

[[Prova pratica 23_01_14]]

[[Albero binario 2002-07-23]]

[[50 Sfumature di Fibonacci]]

[[Esercizio 1 Prova Pratica 20/06/12]]

[[Esercizio 3 Prova Pratica 17/06/14]]

[[Esercizio 3, prova pratica 13/09/2013]]

[[Prova pratica 17 07 14]]

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Main Page

2015-05-12T19:11:50Z

Stefano.zaniboni:

Questo è il Wiki del Corso di Sistemi Operativi

[[Mini Sistema di Videosorveglianza con Raspberry Pi]]

[[Esercizio 1-2 Prova Pratica 30-05-2012]]

[[Esercizio 3 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 30-05-2012]]

[[Esercizio 1 Prova Pratica 23-06-09]]

[[Esercizio 1 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 20-06-2013]]

[[Esercizio 3 Prova Pratica 29-05-14]]

[[Esercizio 2 esame 29/05/2014]]

[[Grep piramidale (non tanto grep) esame 2.7.2003]]

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

[[Linker fisico (Prova pratica 20-02-2014)]]

[[Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)]]

[[Aggiorna cartelle (Prova pratica 23-01-2014)]]

[[Esercizio 3 prova pratica 29 maggio 2014]]

[[Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)]]

[[Esercizio 1 Prova Pratica 12-09-11]]

[[Esercizio 1 Prova Pratica 25-01-2013]]

[[Esercizio 3 Prova Pratica 22-06-2011]]

[[Esercizio 3, prova pratica, 18-07-2013]]

[[Esercizio 3, prova pratica, 17-07-2014]]

[[Esercizio 1, prova pratica, 23-01-2014]]

[[Prova pratica Esercizio 3 esami 17_07_12 - 17_06_14 - 19_07_10]]

[[Prova pratica 23_01_14]]

[[Albero binario 2002-07-23]]

[[50 Sfumature di Fibonacci]]

[[Esercizio 1 Prova Pratica 20/06/12]]

[[Esercizio 3 Prova Pratica 17/06/14]]

[[Esercizio 3, prova pratica 13/09/2013]]

[[Prova pratica 17 07 14]]

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Esercizio 1 Prova Pratica 25-09-2014

2015-05-06T12:44:23Z

Stefano.zaniboni:

<source lang ="text">
Scrivere un programma che preso come parametro un file contenente un elenco di comandi (con I relativi parametri)
li attivi tutti in esecuzione concorrente e rimanga in attesa. Quando il primo termina, vengono terminati (con segnale SIGTERM) tutti gli altri.
(consiglio: puo' essere utile usare la mia libreria s2argv-execs)
esempio:
wta commands
il file commands contiene:
./ttest 40
./ttest 10
./ttest 20
lo script ./ttest contiene:
#!/bin/bash
echo waiting for $1 seconds
sleep $1
echo done $i
l'ouptut sara':
waiting for 40 seconds
waiting for 10 seconds
waiting for 20 seconds
done 10
e poi basta perche' gli altri processi verranno terminati.
</source>

==Soluzione di Stefano Zaniboni==
<source lang ="c">
#include <stdio.h>
#include <s2argv.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <error.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <poll.h>

int main(int argc, char *argv[]){
FILE *stream;
char *line=NULL;
size_t len=0;
ssize_t read;
int i=0;
int status;
pid_t fineFirst; /*memorizzo il pid del primo processo terminato*/
pid_t all[i];
int pipefd[2];
struct pollfd pipe_read_poll;

if(argc!=2){
fprintf(stderr,"Argomento Mancante!\n");
exit(1);
}

stream=fopen(argv[1], "r");
if(stream == NULL)
exit(EXIT_FAILURE);

/*aprire una pipe, dentro al while dove ho la fork fare poll che aspetta un carattere dalla pipe. Lo mando finito il while*/
pipe(pipefd);
pipe_read_poll.fd = pipefd[0];
pipe_read_poll.events = POLLIN;

while((read = getline(&line, &len, stream)) != -1) {
if(fork()==0){
i++;
char **lines=s2argv(line, NULL);
poll(&pipe_read_poll,1,-1);
execvp(lines[0], lines);
all[i]=getpid(); /**/
s2argv_free(lines);
perror("execvp fail!");
exit(1);
}
else
exit(2);
}

/*inviare carattere alla pipe*/
char buf='g';
write(pipefd[1], &buf, 1);
fineFirst=wait(&status);
/*kill the rest of process*/
while(i > 0){
if(all[i] != fineFirst){
kill(all[i], SIGTERM);
}
--i;
}
fclose(stream);
exit(0);
}

</source>

Esercizio 1 Prova Pratica 25-09-2014

2015-05-06T08:49:04Z

Stefano.zaniboni:

<source lang ="text">
Scrivere un programma che preso come parametro un file contenente un elenco di comandi (con I relativi parametri) li attivi tutti in esecuzione concorrente e rimanga in attesa. Quando il primo termina, vengono terminati (con segnale SIGTERM) tutti gli altri. (consiglio: puo' essere utile usare la mia libreria s2argv-execs)
esempio:
wta commands
il file commands contiene:
./ttest 40
./ttest 10
./ttest 20
lo script ./ttest contiene:
#!/bin/bash
echo waiting for $1 seconds
sleep $1
echo done $i
l'ouptut sara':
waiting for 40 seconds
waiting for 10 seconds
waiting for 20 seconds
done 10
e poi basta perche' gli altri processi verranno terminati.
</source>

==Soluzione di Stefano Zaniboni==
<source lang ="c">
#include <stdio.h>
#include <s2argv.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <error.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <poll.h>

int main(int argc, char *argv[]){
FILE *stream;
char *line=NULL;
size_t len=0;
ssize_t read;
int i=0;
int status;
pid_t fineFirst; /*memorizzo il pid del primo processo terminato*/
pid_t all[i];
int pipefd[2];
struct pollfd pipe_read_poll;

if(argc!=2){
fprintf(stderr,"Argomento Mancante!\n");
exit(1);
}

stream=fopen(argv[1], "r");
if(stream == NULL)
exit(EXIT_FAILURE);

/*aprire una pipe, dentro al while dove ho la fork fare poll che aspetta un carattere dalla pipe. Lo mando finito il while*/
pipe(pipefd);
pipe_read_poll.fd = pipefd[0];
pipe_read_poll.events = POLLIN;

while((read = getline(&line, &len, stream)) != -1) {
if(fork()==0){
i++;
char **lines=s2argv(line, NULL);
poll(&pipe_read_poll,1,-1);
execvp(lines[0], lines);
all[i]=getpid(); /**/
s2argv_free(lines);
perror("execvp fail!");
exit(1);
}
else
exit(2);
}

/*inviare carattere alla pipe*/
char buf='g';
write(pipefd[1], &buf, 1);
fineFirst=wait(&status);
/*kill the rest of process*/
while(i > 0){
if(all[i] != fineFirst){
kill(all[i], SIGTERM);
}
--i;
}
fclose(stream);
exit(0);
}

</source>

Esercizio 1 Prova Pratica 25-09-2014

2015-05-05T18:43:21Z

Stefano.zaniboni: Created page with "<source lang ="text"> Scrivere un programma che preso come parametro un file contenente un elenco di comandi (con I relativi parametri) li attivi tutti in esecuzione concorren..."

<source lang ="text">
Scrivere un programma che preso come parametro un file contenente un elenco di comandi (con I relativi parametri) li attivi tutti in esecuzione concorrente e rimanga in attesa. Quando il primo termina, vengono terminati (con segnale SIGTERM) tutti gli altri. (consiglio: puo' essere utile usare la mia libreria s2argv-execs)
esempio:
wta commands
il file commands contiene:
./ttest 40
./ttest 10
./ttest 20
lo script ./ttest contiene:
#!/bin/bash
echo waiting for $1 seconds
sleep $1
echo done $i
l'ouptut sara':
waiting for 40 seconds
waiting for 10 seconds
waiting for 20 seconds
done 10
e poi basta perche' gli altri processi verranno terminati.
</source>

==Soluzione di Stefano Zaniboni==
<source lang ="c">
#include <stdio.h>
#include <s2argv.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <error.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <poll.h>

int main(int argc, char *argv[]){
FILE *stream;
char *line=NULL;
size_t len=0;
ssize_t read;
int i=0;
int status;
pid_t fineFirst; /*memorizzo il pid del primo processo terminato*/
pid_t all[i];
int pipefd[2];
struct pollfd pipe_read_poll;

if(argc!=2){
fprintf(stderr,"Argomento Mancante!\n");
exit(1);
}

stream=fopen(argv[1], "r");
if(stream == NULL)
exit(EXIT_FAILURE);

/*aprire una pipe, dentro al while dove ho la fork fare poll che aspetta un carattere dalla pipe. Lo mando finito il while*/
pipe(pipefd);
pipe_read_poll.fd = pipefd[0];
pipe_read_poll.events = POLLIN;

while((read = getline(&line, &len, stream)) != -1) {
if(fork()==0){
i++;
char **lines=s2argv(line, NULL);
poll(&pipe_read_poll,1,-1);
execvp(lines[0], lines);
all[i]=getpid(); /**/
s2argv_free(lines);
perror("execvp fail!");
exit(1);
}
else
exit(2);
}

/*inviare carattere alla pipe*/
char buf='g';
write(pipefd[1], &buf, 1);
fineFirst=wait(&status);
/*kill the rest of process*/
while(i > 0){
if(all[i] != fineFirst){
kill(all[i], SIGTERM);
}
}
fclose(stream);
exit(0);
}

</source>

Main Page

2015-05-05T18:41:06Z

Stefano.zaniboni:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizio 1 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 20-06-2013]]

[[Esercizio 3 Prova Pratica 29-05-14]]

[[Esercizio 2 esame 29/05/2014]]

[[Grep piramidale (non tanto grep) esame 2.7.2003]]

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

[[Linker fisico (Prova pratica 20-02-2014)]]

[[Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)]]

[[Aggiorna cartelle (Prova pratica 23-01-2014)]]

[[Esercizio 3 prova pratica 29 maggio 2014]]

[[Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)]]

[[Esercizio 1 Prova Pratica 12-09-11]]

[[Esercizio 1 Prova Pratica 25-01-2013]]

[[Esercizio 3 Prova Pratica 22-06-2011]]

[[Esercizio 3, prova pratica, 18-07-2013]]

[[Esercizio 3, prova pratica, 17-07-2014]]

[[Esercizio 1, prova pratica, 23-01-2014]]

[[Prova pratica Esercizio 3 esami 17_07_12 - 17_06_14 - 19_07_10]]

[[Prova pratica 23_01_14]]

[[Albero binario 2002-07-23]]

[[50 Sfumature di Fibonacci]]

[[Esercizio 1 Prova Pratica 20/06/12]]

[[Esercizio 3 Prova Pratica 17/06/14]]

[[Esercizio 3, prova pratica 13/09/2013]]

[[Prova pratica 17 07 14]]

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Prova pratica 2014.07.17

2015-04-18T16:10:20Z

Stefano.zaniboni:

==Testo==
<source lang="text">
Il comando che dovrete implementare come script shell o programma python e' mytx.
Tale comando elenca tutti i file di una directory.
mytx ddd ddd.tx
Ogni riga del file di output (secondo parametro) deve contenere la lunghezza, uno spazio e il nume del file. Dopo l'ultima riga
deve inserire una riga bianca.
ddd.t2 deve contenere l'elenco dei file regolari. Il primo campo e' un numero intero seguito da uno spazio, tutto cio' che segue
fino alla fine riga e' il nome del file.
es.
12 file1
235 file di prova
</source>

==Soluzione di Krusty==
<source lang="python">
import os, sys
from stat import *

out_file = open(sys.argv[2],"w")

for f in os.listdir(sys.argv[1]): #scorre file nella directory
path = os.path.join(sys.argv[1],f)
s = os.stat(path)
if S_ISREG(s.st_mode):
info = str(os.path.getsize(path)) + ' ' + f #scrive dimensione e nome file in info
out_file.write(info + "\n")

out_file.write("\n")
out_file.close()
</source>
==Soluzione di Stefano Zaniboni==
<source lang="python">
#!/bin/usr/env python3

import sys
import os

def writeOnFile(fileToWrite, fileName):
with open(fileToWrite, "a") as afile:
course = fileName
of = os.path.getsize(fileName)
total = str(of)+' '+str(course)
afile.write(str(total))
afile.write('\n')
afile.close()
return None
###########################################
if __name__=="__main__":
myDir=sys.argv[1]
os.system("touch ddd.tx")

for root, dirname, filenames in os.walk(myDir):
for filename in filenames:
writeOnFile("ddd.tx", os.path.join(root,filename))
if os.path.isfile(os.path.join(root, filename)):
writeOnFile("ddd2.tx", filename)
</source>

Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)

2015-04-18T12:31:09Z

Stefano.zaniboni:

Scrivere un programma python o uno script bash che scandisca il sottoalbero relativo alle directory passate come parametri (o alla direcotry corrente se non ci sono parametri) e fornisca in output l'elenco dei file che hanno la stessa somma MD5 (i.e. l'output del comando md5sum).
In output ogni riga deve mostrare un elenco di pathname realtivi a file che hanno la stessa somma MD5 (che quindi sono molto molto probabilmente uguali)

== Soluzione di Stefano Zaniboni ==
<source lang="python">
#!/usr/bin/env python3
from collections import defaultdict
import hashlib
import os
import sys

def md5checksum(filepath):
with open(filepath, "rb") as afile:
m = hashlib.md5()
data = afile.read()
m.update(data)
return m.hexdigest()

def calculate_checksums(search_dir):
checksums = defaultdict(list)

for root, dirs, files in os.walk(search_dir):
for filename in files:
path = os.path.join(root, filename)
checksum = md5checksum(path)
checksums[checksum].append(path)
return checksums

def display_equal_files(checksums):
for checksum, paths in checksums.items():
if len(paths) > 1:
print("MD5 sum: {}".format(checksum))
for path in paths:
print(" {}".format(path))

if __name__ == "__main__":
search_dir = sys.argv[1]
checksums = calculate_checksums(search_dir)
display_equal_files(checksums)

</source>
Ringrazio per l'aiuto nella ricerca dei file con stesso MD5 la comunità di stackoverflow

Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)

2015-04-18T12:30:10Z

Stefano.zaniboni: Created page with "Scrivere un programma python o uno script bash che scandisca il sottoalbero relativo alle directory passate come parametri (o alla direcotry corrente se non ci sono parametri)..."

Scrivere un programma python o uno script bash che scandisca il sottoalbero relativo alle directory passate come parametri (o alla direcotry corrente se non ci sono parametri) e fornisca in output l'elenco dei file che hanno la stessa somma MD5 (i.e. l'output del comando md5sum).
In output ogni riga deve mostrare un elenco di pathname realtivi a file che hanno la stessa somma MD5 (che quindi sono molto molto probabilmente uguali)

<source lang="python">
#!/usr/bin/env python3
from collections import defaultdict
import hashlib
import os
import sys

def md5checksum(filepath):
with open(filepath, "rb") as afile:
m = hashlib.md5()
data = afile.read()
m.update(data)
return m.hexdigest()

def calculate_checksums(search_dir):
checksums = defaultdict(list)

for root, dirs, files in os.walk(search_dir):
for filename in files:
path = os.path.join(root, filename)
checksum = md5checksum(path)
checksums[checksum].append(path)
return checksums

def display_equal_files(checksums):
for checksum, paths in checksums.items():
if len(paths) > 1:
print("MD5 sum: {}".format(checksum))
for path in paths:
print(" {}".format(path))

if __name__ == "__main__":
search_dir = sys.argv[1]
checksums = calculate_checksums(search_dir)
display_equal_files(checksums)

</source>
Ringrazio per l'aiuto nella ricerca dei file con stesso MD5 la comunità di stackoverflow

Main Page

2015-04-18T12:27:44Z

Stefano.zaniboni:

Questo è il Wiki del Corso di Sistemi Operativi

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

[[Linker fisico (Prova pratica 20-02-2014)]]

[[Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)]]

[[Aggiorna cartelle (Prova pratica 23-01-2014)]]

[[Esercizio 3 prova pratica 29 maggio 2014]]

[[Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)]]

[[Esercizio 1 Prova Pratica 12-09-11]]

[[Esercizio 1 Prova Pratica 25-01-2013]]

[[Esercizio 3 Prova Pratica 22-06-2011]]

[[Esercizio 3, prova pratica, 18-07-2013]]

[[Esercizio 3, prova pratica, 17-07-2014]]

[[Esercizio 1, prova pratica, 23-01-2014]]

[[Prova pratica Esercizio 3 esami 17_07_12 - 17_06_14 - 19_07_10]]

[[Prova pratica 23_01_14]]

[[Albero binario 2002-07-23]]

[[50 Sfumature di Fibonacci]]

[[Esercizio 1 Prova Pratica 20/06/12]]

[[Esercizio 3 Prova Pratica 17/06/14]]

[[Esercizio 3, prova pratica 13/09/2013]]

[[Prova pratica 17 07 14]]

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Esercizio 1, prova pratica, 23-01-2014

2015-04-12T04:39:15Z

Stefano.zaniboni:

==Testo==
<source lang="text">
Scrivere un programma in C “linean” che prenda come parametro il pathname di un file e un numero intero (che chiameremo
n). Il programma deve stampare come output il numero di caratteri presenti nella n-ma riga del file se il file e' un file regolare
di testo, non deve stampare nulla negli altri casi. Un file viene considerato di testo se tutti i suoi byte hanno valori compresi nel
range 1-127. Per controllare se il file e' “regolare” usare la system call lstat.
</source>

===Soluzione di Stefano Zaniboni===
<source lang="C">
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <error.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

int isRegular(const char *path){ /*controllo se il file e' regolare*/
struct stat path_stat;
lstat(path, &path_stat);
return S_ISREG(path_stat.st_mode);
}
int main(int argc, char *argv[]){
FILE *fp;
int status=0;
char *line=NULL;
size_t len=0;
int line_to_count=0;
ssize_t read;
int i=1;

if(argc != 3){
fprintf(stderr, "no such arguments \n");
exit(1);
}
line_to_count=atoi(argv[2]);
if(!(status=isRegular(argv[1]))){
printf("error not regular file\n");
exit(EXIT_FAILURE);
}
fp=fopen(argv[1], "r");
if(fp==NULL){
exit(EXIT_FAILURE);
}
while((read=getline(&line,&len,fp)) != -1){
if(i==line_to_count){
printf("retrived line of lenght %zu: \n",i, read);
printf("%s\n", line);
break;
}
i=i+1;
}
free(line);
exit(EXIT_SUCCESS);
}
</source>

Codice scritto e caricato al confine di Stato Italia - Austria

Esercizio 1, prova pratica, 23-01-2014

2015-04-12T04:28:36Z

Stefano.zaniboni: Created page with "==Testo== <source lang="text"> Scrivere un programma in C “linean” che prenda come parametro il pathname di un file e un numero intero (che chiameremo n). Il programma dev..."

Main Page

2015-04-12T04:24:41Z

Stefano.zaniboni:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizio 1, prova pratica, 23-01-2014]]

[[Prova pratica Esercizio 3 esami 17_07_12 - 17_06_14 - 19_07_10]]

[[Prova pratica 23_01_14]]

[[Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)]]

[[Albero binario 2002-07-23]]

[[50 Sfumature di Fibonacci]]

[[Esercizio 1 Prova Pratica 20/06/12]]

[[Esercizio 3 Prova Pratica 17/06/14]]

[[Esercizio 3, prova pratica 13/09/2013]]

[[Prova pratica 17 07 14]]

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Esercizio 1, prova pratica 20.01.2015

2015-04-02T15:18:58Z

Stefano.zaniboni: Created page with "<source lang="text"> Scrivere un programma C di nome filepipe che abbia come unico parametro il pathnae di un file di testo. Questo file contiene due comandi con I rispettivi ..."

<source lang="text">
Scrivere un programma C di nome filepipe che abbia come unico parametro il pathnae di un file di testo.
Questo file contiene due comandi con I rispettivi parametri, uno per riga.
Il programma deve mettere in esecuzione concorrente I due comandi in modo che l'output del primo venga fornito come input del secondo usando una pipe.
Il programma deve terminare quando entrambi I comandi sono terminati.
Esempio: se il file ffff contiene:
ls -l
tac
il comando:
filepipe ffff
deve restituire lo stesso output del comando:
ls -l | tac
</source>
==Soluzione di Stefano.zaniboni==
<source lang="c">
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <error.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[]){
int mypipe[2];
FILE *stream;
char *line=NULL;
size_t len=0;
ssize_t read;

/*controllo il numero degli argomenti passati*/
if(argc != 2){
fprintf(stderr, "no such arguments \n");
exit(1);
}

/*apro il file in sola lettura*/
stream=fopen(argv[1], "r");
if(stream==NULL){
exit(EXIT_FAILURE);
}

/*apro la pipe*/
if(pipe(mypipe) == -1){
fprintf(stderr, "Error pipe\n");
exit (1);
}

if(fork()==0){
close(1); /*chiudo lo stdout*/
dup(mypipe[1]); /*rimpiazzo lo stdout con la pipe*/
close(mypipe[0]); /*chiudo la read della pipe*/
close(mypipe[1]);

read=getline(&line, &len, stream);

char *lines[2]={line, NULL};
execvp(argv[1], lines);
perror("execvp failed");
exit (1);
}
if(fork()==0){
close(0); /*chiudo lo stdin*/
dup(mypipe[0]); /*rimpiazzo lo stdin con la pipe read*/
close(mypipe[1]); /*chiudo la write della pipe*/
close(mypipe[0]);

read=getline(&line, &len, stream);
execvp(argv[1], &line);
perror("execvp 2 failed");
exit (1);
}
close(mypipe[0]);
close(mypipe[1]);
wait(0);
wait(0);
free(line);
fclose(stream);
exit (0);
}

</source>

Il codice ho provato a testarlo ma la shell mi restituisce sempre su entrambe le exec "Permission Denied".

Main Page

2015-04-02T15:18:15Z

Stefano.zaniboni:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Esercizio 1, prova pratica 21.02.2015

2015-04-02T15:08:15Z

Main Page

2015-04-02T15:03:59Z

Stefano.zaniboni:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizio 1, prova pratica 21.02.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]