PLEASE HELP ME WITH THIS ASSIGNMENT...PLEASE....

[Vaidehi Pawar]

I know I'm tooooo late to ask you for help....but please help me out..I
am really new to unix and dont know how to finish this assignment on
time.....proff. said he will be using MOSS to detect whether I
downloaded the code..please help me..

email me : vaidehi.pawar at yahoo.co.in

Assignment 1
Processes, Inter-Process Communication, and Concurrency
Due September 13th midnight
Summary
In
this assignment, you will create two versions of a simple multi-process
game : one without and another with inter-process synchronization. You
will also measure the relative performance of the two versions of your
multi-process game.
Objectives

    * Learn how to create and terminate processes.
    * Learn use of inter-process communication using shared memory, semaphores, signals, etc.
    * Learn the basic workings of CPU scheduling code in Linux.

Part A: Multi-Process Game of Turns

In
this part, you are asked to write a simple program that takes two
command-line arguments P and N. The main process creates P other child
processes, waits for all of them to complete, and then exits. All the
child processes form one logical ring among each other. (In rest of the
description, the term "process" refers to a "child process".) For
example, if the processes are numbered 1 to P, then

    * The next neighbor of process 1 is process 2,
    * The next neighbor of process i is process i+1 for all i < P , and
    * The next neighbor of process P is process 1, which completes a ring among the processes.

Assume
that a shared integer variable, called turn, identifies the number of
the processes whose turn it is at any instant. A second process-local
variable in each process, called me, identifies the identity of each
process (i.e. each process stores its own identity in a per-process
local variable me). A third per-process local variable, called next,
identifies the next process in the ring.

The processes
sequentially pass the turns among each other in the logical ring. When
each process gets its turn, it increments another shared variable
called counter. The pseudo-code within each process for passing turns
might look something as follows. (Note: Replace turn and counter below
with appropriate ways of accessing data within shared memory regions).

    while(turn != me ) 
        /* do nothing - just busy loop*/ ; 

    /* got my turn - increment counter */
    counter = counter + 1;

    /* give the turn to next process */
    turn = next;  

The program terminates when the each process has received N turns.

In the above description, several programming details have been omitted for you to figure out. This includes

    * Creating P child processes from main process.
    * Constructing the logical ring among child processes.
          o Initializing each child process's identity in the me variable.
          o Initializing each child process' next neighbor in the next variable.
    * Initializing the shared memory region and the shared data values.
    * Have the main process wait for child processes to complete N turns before exiting.

Part B: More Efficient Game of Turns

You
might notice that the program you wrote in Part A is inefficient
because each process busy loops till the CPU scheduler kicks it out
(after its time-slice is over) and allows another process to execute
and make progress. (Does the program in Part A have a race condition?
Why or why not?)

What we ideally want is that each process
should be given control of the CPU only when it is that process' turn.
Modify the program you wrote in Part A (using appropriate
synchronization mechanisms) such that each process gets to run (i.e.,
gets control of the CPU) only when it is that process's turn, and at no
other time.

Again, you would need to work out the programming details of how and where to use inter-process synchronization.
Part C: Profiling the Game of Turns

In
this part, you are asked to write user-level profiling code in order to
measure the performance of the two versions of programs you wrote in
Part A and Part B. Use a combination of gettimeofday() system call and
inter-process synchronization to measure (1) the average hand-over time
between two consecutive processes in the ring and (b) the total
execution time to complete N turns. Plot the measured values as graphs
when varying number of processes P and number of turns N. Explain the
results you obtain.
Submission Guidelines

Thanking you,

Ms. Vaidehi Pawar

________________________________


      Check out the all-new face of Yahoo! India. Go to http://in.yahoo.com/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-list/attachments/20080911/abc03a9e/attachment.html>