## Introduction

You are to implement a Robust Dining Philosopher's solution. Your solution is to work in the following way:
• You are free to use the book algorithm (which was presented in class) or any version of the algorithm you might find.
• But you cannot use busy waiting.
• You are to use your Semaphore wrappers to provide necessary semaphores.
• You are to use Solaris shared memory, see below about wrapping these calls in a class or wrapper.
• You are to collaborate in groups of two Again, we will NOT assign partners. Each of you is to write your own code, but use your partner to help debug and test your solution. This means that you MUST contact your partner first prior to sending help requests to the graders or tutors or cs staff. Indicate your partner in your code comments.
• Add to each philosopher a count of the number of times he has eaten.
• When each philosopher has eaten the max number of times (max provided as an input parameter) the philosopher stops eating (his process dies).
• The time period for each eating session is an input parameter (fixed for all philosophers).

While this is a neat problem, as written no one knows what the heck is going on. Thus you MUST have another process, the Waiter, who monitors the Philosopher's table. Because he wants to get a good tip, every 2 seconds the Waiter looks at the table and determines (prints out in a horizontal Santillo format,

• Printout #
• The current values in the state table for each Philosopher, e.g., Hungry (H), Thinking (T), Eating (E), or Done (L).
• How many Philosophers are thinking.
• How many Philosophers are hungry.
• How many Philosophers are eating.
• How many Philosophers remain at the table.

## Termination

When all the Philosophers are done eating the Waiter prints out one more time and the program dies.

## Input Parameters

There are 4 parameters to the program (in order):
• How many Philosophers are coming to dinner, defaults to 5.
• How long (in seconds) each Philosopher eats, defaults to 6.
• How many times each Philosopher eats, defaults to 4.
• How long (in seconds) each Philosopher thinks, defaults to 3.
These parameters are provided as command line parameters and you will get ALL or NONE but you must check for valid values.

## Implementation Notes:

• You are to use your C++ wrapper/class to handle the management of semaphores.
• You are to create a C++ wrapper/class to handle the management of shared memory. This wrapper/class should have at a minimum operations to create, attach, detach, and destroy, shared memory. You can view this wrapper/class as a reasonable interface to the unreasonable interface provided by the operating system.
• Note the word class is used here as an abstraction. You do NOT have to create true C++ Classes.

## Due Dates:

• 5 October, 9PM

## What to Turn-In:

• A Commented, Partial Program Listing that Includes
• An Intro program comment that describes your overall implementation (1 to 2 pages):
• including how long over all it took to write the algorithm; to write the code; and to debug and to make work;
• including the number of semaphores and the use of each semaphore
I say class in a very abstract way; both of these can be true C++ Classes, but they can also be implemented via a set of wrapper functions. The key point is that you are to choose a way to wrap the System Calls for Semaphores and Shared Memory in a way that makes them easy to use, e.g., something like Up(semid) should up a semaphore.
• a description of how you manage your processes, e.g., something about how you manage your main program, the Waiter, etc. Make sure to include comments about how you terminate and determine termination of your processes.
• One or two Sample runs with the default input values. There will be additional input values, which will be used in demonstrating your program.
• We do NOT want a copy of your full program listing!!!!!

## What to Submit

Your full implementation, all the commented code of your running implementation (yes, this is more than the hardcopy that you turn-in).

## Where to Turn-In:

To the plastic bin outside mike's office.

## Notes:

If you decide to NOT implement shared memory with a dynamic size array, then use a max size of 10 philosophers, but expect to loose 4 points. You MUST also indicate this choice in the documentation comments at the front of your program.
We reserve the right to change the problem statement when someone demonstrates the ambiguity of said problem statement.

New: For example, if the input was correct, the program should output at the beginning, correct input, the parameters are set to the inputs, and show that. If there is no input or wrong numbers of input, then your program should output that fact and say that the defaults are used and show what the defaults are. If the values of the input are not valid, then our program should state that and say that the defaults are used, and show what the defaults are.