Welcome to Software Development on Codidact!

Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.

Review Suggested Edit

You can't approve or reject suggested edits because you haven't yet earned the Edit Posts ability.

~~Child process works only once after the parent's two calls to scanf~~

Semaphore controlled child process calculation performed only once after parent's two calls to scanf

~~This program creates a child process and shares two integers (`base` and `height`) through the shared memory.~~
~~The parent process asks four times to insert two integers and wait for the child process to calculate the area.~~
After the four cycles, the parent process waits for the end of its child, deletes the shared memory and the semaphore and ends. The child waits for the new variable (`base`, `height` with semaphore), calculates the area, and prints it, and after the four iterations, it ends.
~~I have to use semaphore for process synchronization and to regulate the critical section. The problem relates to the child process, it works only one time.~~
```c
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <string.h>
#define SEM_KEY (key_t)8765
#define SHM_KEY (key_t)9876
/** Questa union la trovate digitando "man semctl" */
union semun
{
int val; /* Value for SETVAL */
struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */
unsigned short *array; /* Array for GETALL, SETALL */
struct seminfo *__buf; /* Buffer for IPC_INFO(Linux-specific) */
};
/** Tipo di dato condiviso */
struct sh_data
{
int altezza;
int base;
};
/** Funzioni di appoggio per operare con i semafori */
int sem_set(int semid, int val);
int sem_down(int semid);
int sem_up(int semid);
void controlla_area(int, struct sh_data *);
int main()
{
pid_t pid;
int semid, shmid, i;
struct sh_data *data;
// SEMAFORO
// Creazione del semaforo
semid = semget(SEM_KEY, 1, 0666 | IPC_CREAT);
// Inizializzazione semaforo
sem_set(semid, 1);
// SHARED MEMORY
// Creazione shared memory
shmid = shmget(SHM_KEY, sizeof(struct sh_data), 0666 | IPC_CREAT);
// Attach della shm allo spazio di indirizzi del processo
data = (struct sh_data *)shmat(shmid, NULL, 0);
// Processo figlio
pid = fork();
switch (pid)
{
case -1:
perror("Errore fork");
exit(EXIT_FAILURE);
case 0:
controlla_area(semid, data);
exit(EXIT_SUCCESS);
default:
break;
}
// Processo padre
for (i = 0; i < 4; i++)
{
sem_down(semid);
printf("Inserisci la base: ");
scanf("%d", &(data->base));
printf("Inserisci l'altezza: ");
scanf("%d", &(data->altezza));
sem_up(semid);
wait(NULL);
}
// Detach della shared memory
shmdt(data);
// Eliminazione della shared memory
shmctl(shmid, IPC_RMID, NULL);
// Eliminazione semaforo
semctl(semid, 0, IPC_RMID);
exit(EXIT_SUCCESS);
}
void controlla_area(int semid, struct sh_data *data)
{
int area;
sem_down(semid);
area = data->base * data->altezza;
printf("L'area del triangolo è %d\n", area);
sem_up(semid);
}
int sem_set(int semid, int val)
{
union semun s;
s.val = val;
/* Inizializza il valore del semaforo */
return semctl(semid, 0, SETVAL, s);
}
int sem_down(int semid)
{
struct sembuf buff;
buff.sem_num = 0;
buff.sem_op = -1;
buff.sem_flg = SEM_UNDO;
/* Decrementa il valore del semaforo */
return semop(semid, &buff, 1);
}
int sem_up(int semid)
{
struct sembuf buff;
buff.sem_num = 0;
buff.sem_op = 1;
buff.sem_flg = SEM_UNDO;
/* Incrementa il valore del semaforo */
return semop(semid, &buff, 1);
}
```

This program creates a child process that shares two integers (`base` and `height`) with the parent process through the shared memory.
The intended behaviour is that the parent process asks the user four times to insert `base` and `height` and each time waits for the child process to perform a calculation based on these values (using a semaphore). The child waits for the new `base` and `height` using the same semaphore, calculates the area, and prints it, and after the four iterations, it ends.
After the four cycles, the parent process waits for the end of its child, deletes the shared memory and the semaphore and ends.
I have to use semaphore for process synchronization and to regulate the critical section. The problem seems to be with the child process, it performs the calculation only one time.
```c
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <string.h>
#define SEM_KEY (key_t)8765
#define SHM_KEY (key_t)9876
/** Questa union la trovate digitando "man semctl" */
union semun
{
int val; /* Value for SETVAL */
struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */
unsigned short *array; /* Array for GETALL, SETALL */
struct seminfo *__buf; /* Buffer for IPC_INFO(Linux-specific) */
};
/** Tipo di dato condiviso */
struct sh_data
{
int altezza;
int base;
};
/** Funzioni di appoggio per operare con i semafori */
int sem_set(int semid, int val);
int sem_down(int semid);
int sem_up(int semid);
void controlla_area(int, struct sh_data *);
int main()
{
pid_t pid;
int semid, shmid, i;
struct sh_data *data;
// SEMAFORO
// Creazione del semaforo
semid = semget(SEM_KEY, 1, 0666 | IPC_CREAT);
// Inizializzazione semaforo
sem_set(semid, 1);
// SHARED MEMORY
// Creazione shared memory
shmid = shmget(SHM_KEY, sizeof(struct sh_data), 0666 | IPC_CREAT);
// Attach della shm allo spazio di indirizzi del processo
data = (struct sh_data *)shmat(shmid, NULL, 0);
// Processo figlio
pid = fork();
switch (pid)
{
case -1:
perror("Errore fork");
exit(EXIT_FAILURE);
case 0:
controlla_area(semid, data);
exit(EXIT_SUCCESS);
default:
break;
}
// Processo padre
for (i = 0; i < 4; i++)
{
sem_down(semid);
printf("Inserisci la base: ");
scanf("%d", &(data->base));
printf("Inserisci l'altezza: ");
scanf("%d", &(data->altezza));
sem_up(semid);
wait(NULL);
}
// Detach della shared memory
shmdt(data);
// Eliminazione della shared memory
shmctl(shmid, IPC_RMID, NULL);
// Eliminazione semaforo
semctl(semid, 0, IPC_RMID);
exit(EXIT_SUCCESS);
}
void controlla_area(int semid, struct sh_data *data)
{
int area;
sem_down(semid);
area = data->base * data->altezza;
printf("L'area del triangolo è %d\n", area);
sem_up(semid);
}
int sem_set(int semid, int val)
{
union semun s;
s.val = val;
/* Inizializza il valore del semaforo */
return semctl(semid, 0, SETVAL, s);
}
int sem_down(int semid)
{
struct sembuf buff;
buff.sem_num = 0;
buff.sem_op = -1;
buff.sem_flg = SEM_UNDO;
/* Decrementa il valore del semaforo */
return semop(semid, &buff, 1);
}
int sem_up(int semid)
{
struct sembuf buff;
buff.sem_num = 0;
buff.sem_op = 1;
buff.sem_flg = SEM_UNDO;
/* Incrementa il valore del semaforo */
return semop(semid, &buff, 1);
}
```

c multiprocess semaphore shared-memory

Communities

Review Suggested Edit