Concurrent UNIX Processes and shared memory
The goal of this homework is to become familiar with concurrent processing in the Unix operating system. You
will write a program that uses multiple processes to compute the product of two matrices Anm and Bmk. Each
element of the resultant matrix C is given by

There are two types of processes for this homework:

 A \coordinator" process: It is responsible for creating the \worker" processes, and coordinating the computa-
tion. Note that all the computation is done by the \worker" processes. All the information is provided in the
command line (argv).

 A set of \worker" processes: Each worker process reads two integer indices i and j from its argv, computes
the result using expression 1 and returns the result into shared memory before exiting. So, a worker process
is created for every element of the resultant matrix C.

The coordinator process also set a timer at the start of computation. If computation has not  nished by this time,
the coordinator process kills all the workers and then exits. Make sure that you print appropriate message(s).

The code for worker process should be compiled separately and its executable be called worker. The executable for
the coordinator process should be called coord. The two matrices to be multiplied should be kept in separate  les
whose names are to be provided as command line arguments. Thus the program should be executed by

coord -t time A.mat B.mat C.mat

where time is the duration after which the program will be killed (default value: 100).
The format of each matrix  le with n rows and m columns is as follows:
n m
a11 a12 a13


a1m
a21 a22 a23


a2m
a31 a32 a33


a3m
...
...
...
...
...
an1 an2 an3


anm

Each worker process prints its process id, its operands and their sum. Each time coord gets a message back from a
worker, it prints the pid of the worker and the result received into the log  le.

Implementation

The coordinator will create the matrices in the shared memory after reading them from the files, and write the result
into a third file after all the children have  finished.

The code for coordinator and worker processes should be compiled separately and the executables be called coord
and worker.

coord will just spawn the worker processes and wait for them to  nish. Make sure that you never have more than
twenty processes at any time in the system, no matter how big the matrix. coord also sets a timer at the start of
computation to a specied number of seconds (default 100). If computation has not  nished by this time, coord kills
all the worker processes and then exits. Make sure that you print appropriate message(s).

In addition, coord should print a message when an interrupt signal (^C) is received. Other signals are ignored. The
child processes will be killed when the interrupt is received by coord. Then, coord should be killed as well. You can
kill the children explicitly from coord, or by sending a signal to self. Make sure that the processes handle multiple
interrupts correctly. As a precaution, add this feature only after your program is well debugged.

coord will also allocate shared memory for synchronization purposes (flag and turn). Each child will write into a
log  le created by coord. The information to go in the log  le will be the point when the worker attempts to enter
the critical section, and when it exits the critical section. You should keep track of the number of times worker
attempted to enter critical section before it succeeded and write that information in the logle. Writing into the
logle will be performed from inside the critical section. Also add a sleep function in the critical section to sleep for
a random amount of time between 0 and 3 seconds.

The code for main and child processes should be compiled separately and the executables be called coord and worker.
Hints
You will need to set up shared memory in this project to allow the processes to communicate with each other. Please
check the man pages for shmget, shmctl, shmat, and shmdt to work with shared memory.

You will also need to set up signal processing and to do that, you will check on the functions for signal and abort.
If you abort a process, make sure that the parent cleans up any allocated shared memory before dying.
In case you face problems, please use the shell commands ipcs to  nd out any shared memory allocated to you and
free it by using ipcrm.