/*****************************************************************
Il candidato completi il programma fornito, implementando
il main. Il programma ottiene un numero intero N dai parametri
della linea di comando, e crea DUE processi figli.
Il primo processo figlio calcola la divisione intera di N
per 2 e lo comunica al processo padre; il secondo processo figlio calcola il resto
della divisione intera di N per 2 e lo comunica al processo padre.
La comunicazione tra processo padre e processi figlio deve avvenire
tramite un'area di memoria condivisa, dimensionata in modo da poter
contenere un array di due interi. Il primo processo figlio scrive
il suo risultato nel primo elemento dell'array, e il secondo processo
figlio scrive il suo risultato nel secondo elemento.
Il processo padre, DOPO aver creato TUTTI E DUE i processi figli,
aspetta che entrambi i processi figli completino la loro esecuzione;
a quel punto, il processo padre stampa i valori che ha ricevuto.
ESEMPIO
Specificando sulla linea di comando il parametro 11
l'output del programma sara':
Valori ottenuti dai processi figli: 1 5
******************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/wait.h>
int main(int argc, char *argv[]) {
int figli[2];
if(argc != 2) {
printf("Non hai inserito il giusto numero di parametri\n");
return -1;
}
int N = atoi(argv[1]);
/* Crea l'area di memoria */
int segment_id = shmget(IPC_PRIVATE, sizeof(int), S_IRUSR|S_IWUSR);
if (segment_id<0) {
printf("Errore in shmget\n");
return -1;
}
int i;
for(i=0; i<2; i++) {
pid_t pid=fork();
if (pid<0) {
printf("Errore nella fork\n");
/* Dealloco l'area */
if (i==1) {
/* C'è già un figlio, aspetto che termini prima di deallocare */
wait(NULL);
}
shmctl(segment_id, IPC_RMID, NULL);
return -1;
} else if (pid==0) {
/* Processo figlio */
int * p= (int *)shmat(segment_id, NULL, 0); //Per usare un'area di memoria condivsa, il processo deve collegarla al suo spazio di indirizzamento
figli[0] = N/2;
figli[1] = N%2;
shmdt(p); // Quando un processo ha finito di usare un'area di memoria condivisa, deve scollegarla dal suo spazio di indirizzamento
return 0;
}
}
/* Processo Padre */
/* Aspetto la terminazione dei figli */
for(i=0; i<2; i++)
wait(NULL);
int *p=shmat(segment_id, NULL, 0);
printf("I valori sono: %d %d\n", figli[0], figli[1]);
/* Scollego l'area di memoria */
shmdt(p);
/* Dealloco l'area di memoria */
shmctl(segment_id, IPC_RMID, NULL);
return 0;
}
