[sudoNut]

Hey,

I'm currently revising for an concurrent programming exam and would like some thoughts on the following questions.

1. Given the following tree, write a fragment of code that produce processes (using fork()) given the form of the tree.

								  * parent
								 / \
								/   \
							   /	 \
					  child 1 *	   * child 2
							 / \
							/   \
						   /	 \
				  child 1 *	   * child 2
						 .
						.
					   .

2. What is the effect of the following fragments of unix/c code? Illustrate with a binary tree

while(fork() == 0)

Here I'm guessing only the child will continue forking, but what would the tree look like?

while(fork() > 0)

In this one the think the parent would continue forking so how would a tree be form?

So far I have a general understanding that processes calling (parent) get the child pid returned from the fork() call and new process created (child) has 0 returned from the fork() call.

However, I can't seem to get my head around how to take these code fragments and make them into trees and vice-versa.

Any ideas? Thanks in advance.

[sudoNut]

Ok so had a thought about number 2:

while(fork() == 0)

										 * parent
										/  
									   /   
									  /
							   child *
									/
								   /
								  /
						  child *
							   .
							  .
							 .

while(fork() > 0)

										 * parent
										/ \
									   /   \
									  /	 \
							   child *	   * 
									/ \	 / \
								   /   \   /   \
								  /	 \ /	 \
										etc

Still not sure about the first question. Any thoughts?

[Kiriran]

the fork() call will return a pid_t > 0 if you are in the child process and 0 if you are in the parent process.
Hence

while(fork() == 0)

will always create a new child process from the parent process

						parent
|---------------------------|-------------------------|
child1				   child2				   child3

The created child process won't do anything inside the while loop, because fork() returned a pid_t > 0.

while(fork() > 0)

on the otherhand will be called by each child process once, because fork() > 0 is true the first time. The second time it enters the while condition, fork() == 0 (and a new child process is created) The result is

							   parent
									|
							   child1
									|
							   child2
									|
							   child3
									|
							   childN

And if you remeber that fork() returns pid_t > 0 for children and 0 for parent, the first one is easy to solve

[sudoNut]

Kiriran, on 20 Apr, 2009 - 12:53 PM, said:

the fork() call will return a pid_t > 0 if you are in the child process and 0 if you are in the parent process.

That's incorrect. The fork() call will return > 0 if your are in the parent process (returning the pid of the child created) and 0 if you are in the child process.

The answers

1)

while(fork() == 0){

   if(fork() == 0) break;

}

2)

while(fork() == 0)

										 * parent
										/  
									   /   
									  /
							   child *
									/
								   /
								  /
						  child *
							   .
							  .
							 .

3)

while(fork() > 0)
							   parent
|---------------------------|-------------------------|
child1					   child2						 child3

These answers are confirmed by my lecture

We got there in the end