Sistemi Operativi - User contributions [en]

Linker fisico (Prova pratica 20-02-2014)

2015-04-20T07:28:58Z

Calvin42:

Il comando che dovrete implementare come script shell o programma python e' linkdir. linkdir prende due directory come parametri.

linkdir dira dirb

e deve creare in dirb un link fisico (non simbolico) a tutti i file regolari che sono in dira e non in dirb. Se un file regolare e'
presente con lo stesso nome sia in dira sia in dirb, nella directory dirb deve rim

===Soluzione di Claudio Kerov===
<source lang="bash">
#!/usr/local/bin/bash

if [[ -d $1 ]]; then
if [[ -d $2 ]]; then
dir1=$1
dir2=$2
fi
fi

ris1=`find $dir1 -type f | sort | cut -d "/" -f 2-`
ris2=`find $dir2 -type f | sort | cut -d "/" -f 2-`

indir1=`comm -2 -3 <(echo "$ris1") <(echo "$ris2")`
common=`comm -1 -2 <(echo "$ris1") <(echo "$ris2")`

for nome in $indir1; do
`ln ${dir1}/${nome} $dir2`
done

for file in $common; do
if [[ "${dir1}${file}" -ot "${dir2}${file}" ]]; then
`ln ${dir1}/${file} $dir2`
fi
done

</source>

Main Page

2015-04-17T09:22:10Z

Calvin42:

Questo è il Wiki del Corso di Sistemi Operativi

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

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

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

[[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]]

Linker fisico (Prova pratica 20-02-2014)

2015-04-17T09:21:42Z

Calvin42: Created page with "Il comando che dovrete implementare come script shell o programma python e' linkdir. linkdir prende due directory come parametri. linkdir dira dirb e deve creare in dirb un ..."

Il comando che dovrete implementare come script shell o programma python e' linkdir. linkdir prende due directory come parametri.

linkdir dira dirb

e deve creare in dirb un link fisico (non simbolico) a tutti i file regolari che sono in dira e non in dirb. Se un file regolare e'
presente con lo stesso nome sia in dira sia in dirb, nella directory dirb deve rim

<source lang="bash">
#!/usr/local/bin/bash

if [[ -d $1 ]]; then
if [[ -d $2 ]]; then
dir1=$1
dir2=$2
fi
fi

ris1=`find $dir1 -type f | sort | cut -d "/" -f 2-`
ris2=`find $dir2 -type f | sort | cut -d "/" -f 2-`

indir1=`comm -2 -3 <(echo "$ris1") <(echo "$ris2")`
common=`comm -1 -2 <(echo "$ris1") <(echo "$ris2")`

for nome in $indir1; do
`ln ${dir1}/${nome} $dir2`
done

for file in $common; do
if [[ "${dir1}${file}" -ot "${dir2}${file}" ]]; then
`ln ${dir1}/${file} $dir2`
fi
done

</source>

Main Page

2015-04-17T07:23:11Z

Calvin42:

Questo è il Wiki del Corso di Sistemi Operativi

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

[[Esercizio 3 prova pratica 29 maggio 2014]]

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

[[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]]

Aggiorna cartelle (Prova pratica 23-01-2014)

2015-04-16T09:51:30Z

Calvin42: Created page with "Il comando che dovrete implementare come script shell o programma python e' updatedir. Updatedir prende due directory come parametri. updatedir dira dirb Deve copiare in dir..."

Il comando che dovrete implementare come script shell o programma python e' updatedir. Updatedir prende due directory come parametri.

updatedir dira dirb

Deve copiare in dirb tutti i file regolari che sono in dira e non in dirb. Se un file regolare e' presente con lo stesso nome sia in dira sia in dirb, il file deve essere copiato dalla dira alla dirb solo se i contenuti differiscono.

===Soluzione di Claudio Kerov e Stefano Zaniboni===
<source lang="python">
#!/usr/local/bin/python3

import os
import sys
import filecmp
import shutil

if not os.path.isdir(sys.argv[1]):
sys.exit(sys.argv[1]+" non è una directory!")
if not os.path.isdir(sys.argv[2]):
sys.exit(sys.argv[2]+" non è una directory!")

dir1= sys.argv[1]
dir2= sys.argv[2]
lista=[]

for path, dirnames, filenames in os.walk(dir2):
for filename in filenames:
if(os.path.isfile(dir2+filename)):
lista.append(filename)

for path, dirnames, filenames in os.walk(dir1):
for filename in filenames:
if(os.path.isfile(dir1+filename)):
if filename in lista:
if not filecmp.cmp(dir1+filename, dir2+filename):
shutil.copyfile(dir1+filename, dir2+filename)
print("Ho copiato",filename+"! (diff)")
else:
shutil.copy(dir1+filename, dir2)
print("Ho copiato", filename+"!")

</source>

Process Race (Prova pratica 18-07-2013)

2015-03-30T06:36:13Z

Calvin42: /* Soluzione di Claudio Kerov */

<source lang="text">
Esercizio 1: Linguaggio C (obbligatorio): (20 punti)
Una gara fra processi.
Scrivere un programma C che prenda in input (da standard input) alcune righe contenenti comandi con relativi parametri. La lista dei comandi termina quando viene inserita una riga vuota.
A questo punto tutti i comandi vengono eseguiti in modo concorrente e deve venir stampato l'ordine di terminazione.
(E' vietato usare system, popen o simili)
Es.
$ prorace
sleep 30
sleep 10
sleep 20
ls -l
input di una riga vuota .... output di ls -l ....
1 arrivato: ls -l
2 arrivato: sleep 10
3 arrivato: sleep 20
4 arrivato: sleep 30

Esercizio 2: completamento (10 punti)
Si estenda l'esercizio 1 in modo da avere una partenza piu' sincronizzata dei processi.
Tutti i processi devono attendere un evento che li sblocchi tutti insieme, per esempio tutti i processi possono mettersi in
attesa con poll o select sul canale di lettura di una pipe. Quando “prorace” scrive un carattere sulla pipe tutti i processi diventano ready.
</source>

== Soluzione di Federico Giuggioloni ==

<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <poll.h>
#include <string.h>

struct list_el
{
pid_t pid;
char* comando;
struct list_el* next;
};

void insert_el(struct list_el** head, char* command, pid_t id)
{
struct list_el *new_el = malloc(sizeof(struct list_el));
new_el->comando = malloc(sizeof(char) * strlen(command) + 1);
strcpy(new_el->comando, command);
new_el->next = NULL;
new_el->pid = id;

if(*head == NULL)
{
*head = new_el;
}
else
{
struct list_el* tmp = (*head)->next;
(*head)->next = new_el;
new_el->next = tmp;
}

}

int strspl(char*** split, char* string, const char* delim)
{
char* result;
char* parsed = malloc(strlen(string)+1);
char* tofree = parsed;
int size = 2;

char* ptr = string;
while(*ptr != 0)
{
if(*ptr == *delim) size++;
ptr++;
}

if(*split == NULL)
{
*split = malloc(sizeof(char*) * size);
}

strcpy(parsed, string);

int i = 0;
while((result = strtok(parsed, delim)) != NULL)
{
//subsequent calls to strtok must have NULL in the first
//parameter
parsed = NULL;

//(*split)[i] = result;
(*split)[i] = malloc(strlen(result) * sizeof(char) + 1);
strcpy((*split)[i], result);

i++;
}

(*split)[i] = (char*) 0;

free(tofree);
return i;
}

struct list_el* head = NULL;

char* printNamePid(pid_t pid)
{
struct list_el* p = head;
while(p != NULL)
{
if(p->pid == pid) return p->comando;
p = p->next;
}
}

int main(int argc, char* argv[])
{
int n;
char *string;
string = NULL;//malloc(MAX_BUFF * sizeof(char));
int bytes_read;
pid_t pid;
char** splitargs = NULL;
char delim = ' ';
int nFork = 0;
int err;
int pipe_read = 0;
char pipe_char = ' ';

int pipefd[2];
pipe(pipefd);

struct pollfd pipe_read_poll;
pipe_read_poll.fd = pipefd[0];
pipe_read_poll.events = POLLIN;

while((bytes_read = getline(&string, &n, stdin)) != 0)
{
if(strcmp(string, "\n") == 0) break;

string[strlen(string)-1] = 0;
strspl(&splitargs, string, &delim);

pid = fork();
switch(pid)
{
case -1:
printf("Error fork: %s (%d)", strerror(errno), errno);
exit(2);
break;
case 0:
//pipe_read = read(pipefd[0], &pipe_read, 1);
poll(&pipe_read_poll, 1, -1);
err = execvp(splitargs[0], splitargs);
if(err < 0)
{
printf("Error exec: %s (%d)", strerror(errno), errno);
exit(1);
}
exit(0);
break;
default: //PADRE, continua pure
nFork++;
insert_el(&head, string, pid);
break;
}

//free(splitargs); //TODO anche di tutte le stringhe all'interno
splitargs = NULL;
}

int status = 0;
char buf = 'g';
char* comando = NULL;
int ordineArrivo[nFork];
int i = 0;

write(pipefd[1], &buf, 1);

while(i < nFork)
{
pid = wait(&status);
ordineArrivo[i] = pid;
i++;
}

printf("\n\n");
for(i = 0; i < nFork; i++)
{
comando = printNamePid(ordineArrivo[i]);
printf("%d : %s Terminated\n", i, comando);
}
return 0;
}
</source>

==Soluzione di Claudio Kerov ==
Questa è la versione dell'esercizio 1 senza sincronizzazione della partenza dei processi.

<source lang="c">

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

struct lista{
struct lista *next;
char* stringa;
};

void leggiArgomenti(char* comando) //prendo il comando dalla stringa, la divido in programma e argomenti, poi la eseguo
{
char* temp;
char delim= ' ';
char* args[64]; //alla fine uso questo
char** next = args; //ma questo e' quello che riempio
temp= strtok(comando, &delim );

while (temp != NULL)
{
*next++ = temp;
temp = strtok(NULL, &delim);
}
*next = NULL;
execvp(args[0], args);
}

void ins(struct lista *l, char* comando)
{
struct lista *tmp = malloc(sizeof(struct lista));
tmp->stringa = malloc(sizeof(char)*strlen(comando)+1);
tmp->next= l->next;
strcpy(tmp->stringa, comando);
l->next = tmp;

}

int main (int argc, char *argv[])
{

size_t n;
int status = 0;
char *riga= (char*)malloc(sizeof(char));
struct lista *lista_arrivi=(struct lista*) malloc(sizeof(struct lista));
struct lista *tmp = lista_arrivi;
lista_arrivi->next = NULL;

while( (getline(&riga, &n, stdin)!=0))
{
if (strcmp(riga, "\n")==0)
break;

ins(lista_arrivi, riga);
counter++;

}

while(lista_arrivi!=NULL)
{
pid_t pid = fork();
switch(pid)
{
case -1: exit(2);
break;
case 0: //processo figlio che prende in input i comandi

leggiArgomenti(lista_arrivi->stringa);
break;
default: //processo padre che stampera' la lista
lista_arrivi= lista_arrivi->next;
break;
}

}

tmp = tmp->next;

while(tmp!=NULL)
{
wait(&status);
printf("Terminato: %s\n", tmp->stringa);
tmp= tmp->next;
}

return 0;
}

</source>

Process Race (Prova pratica 18-07-2013)

2015-03-28T18:49:45Z

Calvin42: /* Soluzione di Federico Giuggioloni */

<source lang="text">
Esercizio 1: Linguaggio C (obbligatorio): (20 punti)
Una gara fra processi.
Scrivere un programma C che prenda in input (da standard input) alcune righe contenenti comandi con relativi parametri. La lista dei comandi termina quando viene inserita una riga vuota.
A questo punto tutti i comandi vengono eseguiti in modo concorrente e deve venir stampato l'ordine di terminazione.
(E' vietato usare system, popen o simili)
Es.
$ prorace
sleep 30
sleep 10
sleep 20
ls -l
input di una riga vuota .... output di ls -l ....
1 arrivato: ls -l
2 arrivato: sleep 10
3 arrivato: sleep 20
4 arrivato: sleep 30

Esercizio 2: completamento (10 punti)
Si estenda l'esercizio 1 in modo da avere una partenza piu' sincronizzata dei processi.
Tutti i processi devono attendere un evento che li sblocchi tutti insieme, per esempio tutti i processi possono mettersi in
attesa con poll o select sul canale di lettura di una pipe. Quando “prorace” scrive un carattere sulla pipe tutti i processi diventano ready.
</source>

== Soluzione di Federico Giuggioloni ==

<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <poll.h>
#include <string.h>

struct list_el
{
pid_t pid;
char* comando;
struct list_el* next;
};

void insert_el(struct list_el** head, char* command, pid_t id)
{
struct list_el *new_el = malloc(sizeof(struct list_el));
new_el->comando = malloc(sizeof(char) * strlen(command) + 1);
strcpy(new_el->comando, command);
new_el->next = NULL;
new_el->pid = id;

if(*head == NULL)
{
*head = new_el;
}
else
{
struct list_el* tmp = (*head)->next;
(*head)->next = new_el;
new_el->next = tmp;
}

}

int strspl(char*** split, char* string, const char* delim)
{
char* result;
char* parsed = malloc(strlen(string)+1);
char* tofree = parsed;
int size = 2;

char* ptr = string;
while(*ptr != 0)
{
if(*ptr == *delim) size++;
ptr++;
}

if(*split == NULL)
{
*split = malloc(sizeof(char*) * size);
}

strcpy(parsed, string);

int i = 0;
while((result = strtok(parsed, delim)) != NULL)
{
//subsequent calls to strtok must have NULL in the first
//parameter
parsed = NULL;

//(*split)[i] = result;
(*split)[i] = malloc(strlen(result) * sizeof(char) + 1);
strcpy((*split)[i], result);

i++;
}

(*split)[i] = (char*) 0;

free(tofree);
return i;
}

struct list_el* head = NULL;

char* printNamePid(pid_t pid)
{
struct list_el* p = head;
while(p != NULL)
{
if(p->pid == pid) return p->comando;
p = p->next;
}
}

int main(int argc, char* argv[])
{
int n;
char *string;
string = NULL;//malloc(MAX_BUFF * sizeof(char));
int bytes_read;
pid_t pid;
char** splitargs = NULL;
char delim = ' ';
int nFork = 0;
int err;
int pipe_read = 0;
char pipe_char = ' ';

int pipefd[2];
pipe(pipefd);

struct pollfd pipe_read_poll;
pipe_read_poll.fd = pipefd[0];
pipe_read_poll.events = POLLIN;

while((bytes_read = getline(&string, &n, stdin)) != 0)
{
if(strcmp(string, "\n") == 0) break;

string[strlen(string)-1] = 0;
strspl(&splitargs, string, &delim);

pid = fork();
switch(pid)
{
case -1:
printf("Error fork: %s (%d)", strerror(errno), errno);
exit(2);
break;
case 0:
//pipe_read = read(pipefd[0], &pipe_read, 1);
poll(&pipe_read_poll, 1, -1);
err = execvp(splitargs[0], splitargs);
if(err < 0)
{
printf("Error exec: %s (%d)", strerror(errno), errno);
exit(1);
}
exit(0);
break;
default: //PADRE, continua pure
nFork++;
insert_el(&head, string, pid);
break;
}

//free(splitargs); //TODO anche di tutte le stringhe all'interno
splitargs = NULL;
}

int status = 0;
char buf = 'g';
char* comando = NULL;
int ordineArrivo[nFork];
int i = 0;

write(pipefd[1], &buf, 1);

while(i < nFork)
{
pid = wait(&status);
ordineArrivo[i] = pid;
i++;
}

printf("\n\n");
for(i = 0; i < nFork; i++)
{
comando = printNamePid(ordineArrivo[i]);
printf("%d : %s Terminated\n", i, comando);
}
return 0;
}
</source>

==Soluzione di Claudio Kerov ==
<source lang="c">

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

struct lista{
struct lista *next;
char* stringa;
};

void leggiArgomenti(char* comando) //prendo il comando dalla stringa, la divido in programma e argomenti, poi la eseguo
{
char* temp;
char delim= ' ';
char* args[64]; //alla fine uso questo
char** next = args; //ma questo e' quello che riempio
temp= strtok(comando, &delim );

while (temp != NULL)
{
*next++ = temp;
temp = strtok(NULL, &delim);
}
*next = NULL;
execvp(args[0], args);
}

void ins(struct lista *l, char* comando)
{
struct lista *tmp = malloc(sizeof(struct lista));
tmp->stringa = malloc(sizeof(char)*strlen(comando)+1);
tmp->next= l->next;
strcpy(tmp->stringa, comando);
l->next = tmp;

}

int main (int argc, char *argv[])
{

size_t n;
int status = 0;
char *riga= (char*)malloc(sizeof(char));
struct lista *lista_arrivi=(struct lista*) malloc(sizeof(struct lista));
struct lista *tmp = lista_arrivi;
lista_arrivi->next = NULL;

while( (getline(&riga, &n, stdin)!=0))
{
if (strcmp(riga, "\n")==0)
break;

ins(lista_arrivi, riga);
counter++;

}

while(lista_arrivi!=NULL)
{
pid_t pid = fork();
switch(pid)
{
case -1: exit(2);
break;
case 0: //processo figlio che prende in input i comandi

leggiArgomenti(lista_arrivi->stringa);
break;
default: //processo padre che stampera' la lista
lista_arrivi= lista_arrivi->next;
break;
}

}

tmp = tmp->next;

while(tmp!=NULL)
{
wait(&status);
printf("Terminato: %s\n", tmp->stringa);
tmp= tmp->next;
}

return 0;
}

</source>

Main Page

2015-02-28T13:44:11Z

Calvin42:

Questo è il Wiki del Corso di Sistemi Operativi

[[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-02-28T13:43:58Z

Calvin42:

Questo è il Wiki del Corso di Sistemi Operativi

[[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]]

Problema Dei Filosofi

2015-02-28T13:34:08Z

Calvin42: Created page with "Cinque filosofi passano la loro vita a pensare e a mangiare (alternativamente). Per mangiare fanno uso di una tavola rotonda con 5 sedie, 5 piatti e 5 posate fra i piatti per ..."

Cinque filosofi passano la loro vita a pensare e a mangiare (alternativamente). Per mangiare fanno uso di una tavola rotonda con 5 sedie, 5 piatti e 5 posate fra i piatti per mangiare. Un filosofo, per mangiare, ha bisogno di entrambe le posate (destra/sinistra). Per pensare, lascia le posate dove le ha prese. Dato che prediligono gli spaghetti e che gli spaghetti non si mangiano con due forchette, utilizzeranno un paio di bacchette, ma il concetto rimane lo stesso.
Il problema dei filosofi mostra come gestire situazioni in cui i processi entrano in competizione per accedere ad insiemi di risorse a intersezione non nulla.

==Implementazione==
Ho utilizzato la libreria "semaphore.h" per gestire i semafori.

<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#include <unistd.h>

sem_t chopstick[5];

void dining(int i)
{
pid_t pid=fork();
if (pid==-1)
exit(2);
if (pid)
{
printf("Sono il %d figlio di %i!\n\n\n", i, getppid());
// while(1)
{
printf("%d sta pensando...\n", getpid());
sem_wait(&(chopstick[i]));
sem_wait(&(chopstick[(i+1)%5]));
printf("%d sta mangiando...\n", getpid());
sem_post(&(chopstick[i]));
sem_post(&(chopstick[(i+1)%5]));
}

}
else /* processo figlio */
if((i+1)!=5)
{
dining(i+1);
}
else /* Non ci sono filosofi rimanenti */
{
printf("Hanno pensato e mangiato tutti!\n");
return;
}
return;

}

int main(int argc, char* argv[])
{
pid_t pid;
int i;
/* Inizializzo i semafori
* il primo parametro e' l'indirizzo del semaforo
* il secondo e' 0 se si utilizzano i thread, altrimenti processo
* il terzo e' il valore iniziale
*/
for(i=0; i<5; i++)
sem_init(&(chopstick[i]), 1, 1);

i=1; /*i diventa 1 perche' il primo filosofo lo faccio mangiare subito */

pid=fork();

if(pid==-1)
{
exit(2);//errore
}
else
if (pid)
{
/* Per rompere la simmetria faccio mangiare per primo un filosofo
* in questo caso il filosofo 0
*/
printf("Sono %d, il padre di tutti!\\n\n\n", getpid());
// while(1)
{
printf("%d sta pensando...\n", getpid());
sem_wait(&(chopstick[1]));
sem_wait(&(chopstick[0]));
printf("%d sta mangiando...\n", getpid());
sem_post(&(chopstick[1]));
sem_post(&(chopstick[0]));
}
}
else /* Primo processo figlio */
{
printf("Padre: %d\n\n", getppid());
dining(i);
}

return 0;
}
</source>

== Commenti ==
Ho rimosso il while(1) per evitare che il programma andasse in loop, quindi il problema viene risolto una sola volta. Ho effettivamente scritto un programma che ricorsivamente crea dei processi '''fratelli''', e non figli, del primo processo '''figlio''', come si puo' vedere dall'output.

[[File:Output_filosofi_c.png|300 px]]

File:Output filosofi c.png

2015-02-28T13:27:46Z

Calvin42:

Sistemi Operativi:Main Page

2014-11-03T12:52:59Z

Calvin42: Calvin42 moved page Sistemi Operativi:Main Page to Main Page over redirect: revert

#REDIRECT [[Main Page]]

Main Page

2014-11-03T12:52:59Z

Calvin42: Calvin42 moved page Sistemi Operativi:Main Page to Main Page over redirect: revert

Questo è il Wiki del Corso di Sistemi Operativi

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

[[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

2014-11-03T09:22:00Z

Calvin42: Calvin42 moved page Main Page to Sistemi Operativi:Main Page