Description
This assignment involves using the LINUX system function pipe() as well as fork().
We will have three processes which communicate with each other using pipes. The three processes will be parent, child and grandchild.
Their communication will run in a ring like this:
Pipe A Pipe B
—> Parent ———-> Child ———-> Grandchild —>
| |
<————–<————–<————-<———–
Pipe C
Each process will read a number (in character format) from a pipe, convert it to an integer, do a bit of arithmetic, convert the result to character format (a string) and write it into the other pipe for the next process to read.
Write a program on the turing system using C or C++ to implement this.
The following description assumes that the strings involved are C-style strings (character arrays ending in \0). It should also be
possible to do this using the C++ string class. If you wish to do so, see the notes below.
———————————————————————
Main program
1. Declare three pipe variables (which I will call Pipe A, Pipe B and
Pipe C). Each is an array of two integers.
2. Call the pipe() function once for each pipe variable.
3. If any use of pipe() fails (returning -1), print an error
message (such as “pipe #1 error”) and exit with a status of -5.
4. Call the fork() function twice to create the three processes:
once in the parent and then again in the child. Do not create
more than 3 processes.
If fork() fails (returning -1), print an error message (such as
“fork #2 error”) and exit with a status of -5.
5. At this point we have three processes, parent, child and
grandchild. Each of these should call a function to do the rest
of its work. We can call these PWork() for the parent, CWork()
for the child and GWork() for the grandchild. Before calling its
function, each process should close the appropriate ends of the
pipes it will use. (The parent reads from Pipe C and writes to
Pipe A, so it should close the write end of Pipe C and the read
end of Pipe A, and likewise for the other two.)
When the functions end, the processes should close the remaining
ends of the pipes and then exit with a status of 0. (The child
should use wait() to wait until the grandchild terminates, and the
parent should do the same for the child.)
6. Return a value of 0. (This is not really needed as we are using
exit(), but it’s a good habit.)
———————————————————————
What do the functions do?
1. Declare two char arrays, Buffer and Value, each of size at least
10. Initialize Value to “1”. Also declare an integer M with the
initial value 1.
In PWork() (but not in the other two), start by writing Value to
the appropriate pipe. Print a message announcing this is the
parent and providing the value of Value. (This is the principal
difference between PWork() and the others: it starts the
processing.)
2. In a loop, while M is no more than 99999999 (that is eight 9s), do
the following:
(a) Read one byte at a time from the appropriate pipe and store
them in Value, building a string. Stop when you find ‘\0’.
(b) Make sure Value ends properly as a string with ‘\0’.
(c) Convert the string Value to an integer value in M.
(d) Compute M = 4 * M + 3.
(e) Convert M to a string in Buffer.
(f) Write Buffer to the appropriate pipe. Print a message
identifying who is printing (parent, child or grandchild) and
providing the value of Value.
———————————————————————
Option to use the C++ string class
If you prefer to use the C++ string class, you will need to make a few changes to the functions:
— The variables Buffer and Value should be declared as strings.
— When you write a string to the pipe, the other process must be
able to identify the end of the transmission. Therefore, use
some character such as ‘@’ as a delimiter.
— When a process reads a string from the pipe, it should read one
byte at a time until it finds the delimiter. Do not print the
delimiter or use it in converting a string to an integer.
———————————————————————
Notes
You should decide for yourself what arguments you need to pass to these functions.
As the three functions are so similar, you may be able to improve
the design by making the overlapping part into a separate function.
You may want to read up on read() and write() and how to convert a
string to an integer.
Please print your output without buffering. As in Assignment 1, the simplest way to do this is to use stderr instead of stdout.
Your program should use reasonable variable names and should be appropriately indented and well documented. You can find style guidelines on the web sites of the CSCI 240 and 241 courses.
You should have a makefile. The name of the executable file should be “Assign2”.
When you are done, you need to submit your work on Blackboard. As in Assignment 1, you should create a tar file containing the two files involved: the program file and the makefile. To do this, you need the “tar” utility.
Do the following (replacing “Znumber” with your own Z-ID):
(a) Create a subdirectory named Znumber_A2_dir.
(b) Copy the three files into it.
(c) In the parent directory of Znumber_A2_dir, use this command:
tar -cvf Znumber_A2.tar Znumber_A2_dir
Use an FTP program to retrieve the tar file and then submit it on Blackboard. The TA will move it to turing, extract the files and run your makefile, as in:
tar -xvf Znumber_A2.tar
cd Znumber_A2_dir
make
Assign2
If your makefile does not run or your program does not compile and run, you will receive no credit.
———————————————————————
Sample Output
This is an example of the output. If you run your program several
time, you may find you have some of the lines in a different order.
Parent: Value = 1
Child: Value = 7
Grandchild: Value = 31
Parent: Value = 127
Child: Value = 511
Grandchild: Value = 2047
Parent: Value = 8191
Child: Value = 32767
Grandchild: Value = 131071
Parent: Value = 524287
Child: Value = 2097151
Grandchild: Value = 8388607
Parent: Value = 33554431
Child: Value = 134217727
Grandchild: Value = 536870911
Parent: Value = 2147483647
