CODEWITHSUNDEEP
operating-system
Pratik Jain
Pratik Jain

Reputation: 11

order of execution of forked processes

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/sem.h>
#include<sys/ipc.h>
int sem_id;
void update_file(int number)
{
    struct sembuf sem_op;
    FILE* file;
    printf("Inside Update Process\n");
    /* wait on the semaphore, unless it's value is non-negative. */
    sem_op.sem_num = 0;
    sem_op.sem_op = -1;   /* <-- Amount by which the value of the semaphore is to be decreased */
    sem_op.sem_flg = 0;
    semop(sem_id, &sem_op, 1);

    /* we "locked" the semaphore, and are assured exclusive access to file.  */
    /* manipulate the file in some way. for example, write a number into it. */
    file = fopen("file.txt", "a+");
    if (file) {
        fprintf(file, " \n%d\n", number);
        fclose(file);
    }

    /* finally, signal the semaphore - increase its value by one. */
    sem_op.sem_num = 0;
    sem_op.sem_op = 1;
    sem_op.sem_flg = 0;
    semop( sem_id, &sem_op, 1);
}
void write_file(char* contents)
{
    printf("Inside Write Process\n");
    struct sembuf sem_op;
    sem_op.sem_num = 0;
    sem_op.sem_op = -1;
    sem_op.sem_flg = 0;
    semop( sem_id, &sem_op, 1);

    FILE *file = fopen("file.txt","w");
    if(file)
    {
        fprintf(file,contents);
        fclose(file);
    }

    sem_op.sem_num = 0;
    sem_op.sem_op = 1;
    sem_op.sem_flg = 0;
    semop( sem_id, &sem_op, 1);
}
int main()
{
    //key_t key = ftok("file.txt",'E');
    sem_id = semget( IPC_PRIVATE, 1, 0600 | IPC_CREAT);
    /*here 100 is any arbit number to be assigned as the key of the
    semaphore,1 is the number of semaphores in the semaphore set, */
    if(sem_id == -1)
    {
        perror("main : semget");
        exit(1);
    }
    int rc = semctl( sem_id, 0, SETVAL, 1);
    pid_t u = fork();
    if(u == 0)
    {
        update_file(100);
        exit(0);
    }
    else
    {
        wait();
    }
    pid_t w = fork();
    if(w == 0)
    {
        write_file("Hello!!");
        exit(0);
    }
    else
    {
        wait();
    }
}

If I run the above code as a c code, the write_file() function is called after the update_file () function Whereas if I run the same code as a c++ code, the order of execution is reverse... why is it so??

Upvotes: 1

Views: 95

Answers (1)

Arcturian MegaDonkey
Arcturian MegaDonkey

Reputation: 11

Just some suggestions, but it looks to me like it could be caused by a combination of things:

  1. The wait() call is supposed to take a pointer argument (that can be NULL). Compiler should have caught this, but you must be picking up another definition somewhere that permits your syntax. You are also missing an include for sys/wait.h. This might be why the compiler isn't complaining as I'd expect it to.

  2. Depending on your machine/OS configuration the fork'd process may not get to run until after the parent yields. Assuming the "wait()" you are calling isn't working the way we would be expecting, it is possible for the parent to execute completely before the children get to run.

Unfortunately, I wasn't able to duplicate the same temporal behavior. However, when I generated assembly files for each of the two cases (C & C++), I noticed that the C++ version is missing the "wait" system call, but the C version is as I would expect. To me, this suggests that somewhere in the C++ headers this special version without an argument is being #defined out of the code. This difference could be the reason behind the behavior you are seeing.

In a nutshell... add the #include, and change your wait calls to "wait(0)"

Upvotes: 1

Related Questions