Where the switching of parent process and child process is happening here? - c++

Question

What the code actually does is takes input from parent process, sends it to child process through pipe. Child process reverses it then sends it back to parent through another pipe. There is no waitpid() or wait() function in the code.
The question is: How the process switching is working here? How write() and read() functions are working here?
Here is the code:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <iostream>
#define li long int
using namespace std;
void ReverseAString(char input[])
{
li length = strlen(input),i;
char hold;
for(i=0;i<length/2;i++)
{
hold = input[i];
input[i] = input[length-(i+1)];
input[length-(i+1)] = hold;
}
}
int main()
{
pid_t ChildOrParentId;
int fifoParent[2],fifoChild[2],in;
if(pipe(fifoParent)==-1)
{
cout<<"Problem in creating Parent's Pipe"<<endl;
perror("Parent's Pipe");
exit(1);
}
if(pipe(fifoChild)==-1)
{
cout<<"Problem in creating Child's Pipe"<<endl;
perror("Child's Pipe");
exit(1);
}
ChildOrParentId = fork();
if(ChildOrParentId==0)
{
char buf[100],collected[100];
close(fifoParent[0]);
close(fifoChild[1]);
in = 0;
while(read(fifoChild[0],buf,1)>0)
{
collected[in]=buf[0];
in++;
}
collected[in]=0;
cout<<"Read from Child "<<collected<<endl;
ReverseAString(collected);
cout<<"After Reversing: "<<collected<<endl;
write(fifoParent[1],collected,sizeof(collected));
close(fifoParent[1]);
}
else
{
char buf[100],collected[100];
close(fifoParent[1]);
close(fifoChild[0]);
in = 0;
cout<<"Enter a string: ";
gets(buf);
write(fifoChild[1],buf,sizeof(buf));
close(fifoChild[1]);
while(read(fifoParent[0],buf,1)>0)
{
collected[in] = buf[0];
in++;
}
collected[in] = 0;
cout<<"Read from Parent "<<collected<<endl;
}
return 0;
}
Output window looks like this:
Enter a string: abc // abc input given
Read from child abc
After reversing: cba
Read from parent cba

Answer 1

Normally, read on an empty pipe blocks until data is made available by writing to the write end of the pipe.
Thus, the child process can't continue execution past this line until it receives data from the parent; it blocks waiting for it:
while(read(fifoChild[0],buf,1)>0)
Once it has read the string, it wakes up, reverses it, and writes it back to the parent. The parent might also be blocked when it reaches the following line, waiting for the child process to write the reversed string:
while(read(fifoParent[0],buf,1)>0)
The blocking behaviour of read is similar to the blocking behaviour of wait or waitpid, but it waits for data to arrive on the file descriptor, rather than waiting for a child process to change status.
In general, parent and child processes execute simultaneously, except when one or both are blocked on a system call.

Answer 2

The moment you call fork(), a second process is created, and both processes are at this point in the code. The only way to tell if you're the new child process or the original parent process is to look at the return value of fork(). In the documentation, you can see that if fork() returns 0, you are in the child process. So basically, the then block of the if(ChildOrParentId==0) statement only runs in the child process, and the else block only runs in the parent process.
The rest of the explanation is pretty straight forward if you look at those two blocks as different programs. The parent block asks for a string, sends it to the child, waits for the child to send something back, then prints what the child sent. Meanwhile, the child block waits for something from the parent, prints what it gets, reverses it and prints that, then sends the reversed string back to the parent.