Communities

Writing
Writing
Codidact Meta
Codidact Meta
The Great Outdoors
The Great Outdoors
Photography & Video
Photography & Video
Scientific Speculation
Scientific Speculation
Cooking
Cooking
Electrical Engineering
Electrical Engineering
Judaism
Judaism
Languages & Linguistics
Languages & Linguistics
Software Development
Software Development
Mathematics
Mathematics
Christianity
Christianity
Code Golf
Code Golf
Music
Music
Physics
Physics
Linux Systems
Linux Systems
Power Users
Power Users
Tabletop RPGs
Tabletop RPGs
Notifications
Mark all as read
Q&A

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

+2
−3

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.

#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);
}
Why does this post require moderator attention?
You might want to add some details to your flag.
Why should this post be closed?

3 comment threads

Define your terms. (3 comments)
I don't think the problem is the semaphore (1 comment)
Fixes and clarifications needed (2 comments)

1 answer

+2
−0

One problem of your code is the one that @celtschk already has reported: You start one child process, and that one child process does the area calculation exactly once.

Thus, one step towards the proper solution is to either spawn one child process per calculation, or have the child process also perform the calculation in a loop.

However, there is another issue with your solution: The synchronization does not work properly. Your semaphore acts as a mutex for the shared memory, but not as an indication of data readiness. That is, depending on the actual timing, the calculation might start even if no data is available.

You will see this when modifying the code as follows:

    default:
        break;
    }

    usleep(1000000);

    // Processo padre
    for (i = 0; i < 4; i++)
    {

The added usleep will delay the parent process long enough for the child process to start executing. And, as a result the computation starts even before the first value has been queried from the user.

You can reach your (assumed) goal, for example, by changing the code in the following way:

#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_wait_for_zero(int semid);
int sem_down(int semid);
int sem_add_two(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, 0); // no data available yet

    // 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_wait_for_zero(semid); // no data yet or ready with processing
        printf("Inserisci la base: ");
        scanf("%d", &(data->base));
        printf("Inserisci l'altezza: ");
        scanf("%d", &(data->altezza));
        sem_add_two(semid); // signal that data is available
    }
    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 i;

    for (i = 0; i < 4; i++)
    {
        int area;

        sem_down(semid); // wait until data is available (semaphore has value 2) and decrement from 2 to 1
        area = data->base * data->altezza;
        printf("L'area del triangolo è %d\n", area);
        sem_down(semid); // signal that data processing is done (decrement from 1 to 0)
    }
}

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_wait_for_zero(int semid)
{
    struct sembuf buff;
    buff.sem_num = 0;
    buff.sem_op = 0;
    buff.sem_flg = SEM_UNDO;

    // Wait for the semaphore value to become zero
    return semop(semid, &buff, 1);
}

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_add_two(int semid)
{
    struct sembuf buff;
    buff.sem_num = 0;
    buff.sem_op = 2;
    buff.sem_flg = SEM_UNDO;

    // add two to the value of the semaphore
    return semop(semid, &buff, 1);
}

And, finally, as your code seems to calculate the area of a triangle: The area of a triangle should be calculated using the formula base * height / 2 (but probably better using floating point) rather than just base * height.

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

Sign up to answer this question »

This community is part of the Codidact network. We have other communities too — take a look!

You can also join us in chat!

Want to advertise this community? Use our templates!

Like what we're doing? Support us! Donate