Due April 19th, 2002, at 9 PM

Introduction

Mutual exclusion is to be provided by Solaris semaphores (see semctl). The shared buffer is to be provided by Solaris shared memory (see shmctl).

Producer

Your producer, a fat old Sergeant, is a process that periodically attempts to add a new person with long hair to the buffer of chairs in the barbershop. "Periodically" means that the producer uses the sleep function with a sleep time determined by a command line input parameter. The sleep time must be between 1 and 5 seconds, with a default of 3 seconds. If there are no open seats, then the Sergeant waits until there is an empty chair (note that in this case more than 5 seconds might elapse before the next person is seated).

Buffer

The producer and consumer share a buffer of 20 chairs, but there are 3 FIFO lists within the 20 chairs. At any time there may be only 20 people in the barbershop chairs with a random distribution of Officers, NonComs, and Grunts, and 1 person getting a haircut. Note: if there is only one type of person in the barbershop, then the shop queue acts like a circular buffer.

The FIFO lists must be implemented as linked lists using integer indices as pointers.

Consumer

Your consumer process is the Barber, a wiry old private. Haircuts have an individual time between 1 and 5 seconds, controlled by the input file (see below). The Barber gives priority for service: if there are any officers waiting, they get their haircuts first, even if a NonCom or grunt has been waiting longer; similarly, NonComs get priority over grunts.

Input File

The pattern of people arriving for haircuts is controlled by an input file, read from the standard input. The input is a series of 2-digit numbers that encode both the type of soldier and the time needed for a haircut:

• The first digit gives the rank: 0 for grunts, 1 for NonComs, and 2 for officers;
• The second digit gives the amount of time needed for a haircut, which ranges from 1 to 5 seconds.

You may assume that the input file consists exclusively of numbers, but you must make sure that the numbers are valid, rejecting illegal soldier types and invalid haircut times. The easiest way to process the input is to read a number and then separate the digits using integer division and the modulus operator.

Here is a sample input file that will not stress your program very much.

Output

As in the Dining Philosophers project, the participants in the game are so busy doing things that they don't have a chance to figure out what is going on. Thus you MUST have another process, the Lieutenant, who monitors the overall barbershop. Because he is young and stupid, every 2 seconds the Lieutenant pokes his head into the barbershop to determine:

• The total number of officers that have entered the system.
• How many officers are waiting in the barbershop.
• How many officers have gotten their haircut.
• The total number of NonComs that have entered the system.
• How many NonComs are waiting in the barbershop.
• How many NonComs have gotten their haircut.
• The total number of grunts that have entered the system.
• How many grunts are waiting in the barbershop.
• How many grunts have gotten their haircut.
• The total number of empty chairs.
• The total number of occupied chairs.
• Who is currently in the barber chair (officer, NonCom, or grunt).

The Lieutenant numbers each output line sequentially (easier to watch the time fly).

Optionally (controlled by the second parameter to the program) the Lieutenant can also dump the contents of the three queues (everyone in the queue, their chair number, etc.).

A short example of the output should clarify some of these points. Your output must match the sample format exactly to make grading easier.

In the sample output, lines 1-6 of each group are what is normally printed out, while lines 7-10 are the additional lines produced if parameter 2 is nonzero. Note that the person in the chair with the lowest number is the next person of that category to have their hair cut. Also note how position numbers change as someone's hair is cut, i.e., in the first group (watch #20), the next NC is 18, in the second group (watch #21), the next NC is 17 (because the guy in 18 moved to the barber chair. Finally, note how there is only one entry in each column (since each array slot can only hold one type of person) and the grunt queue is not in any particular order.

Arguments

The barbershop program must be invoked with three arguments:

1. How long in seconds the consumer process should sleep before starting -- i.e., the time it takes the barber to have his coffee in the morning. This means that the producer (Sergeant) is running, but the consumer has not yet started. You can set this to a high value to find out how your barber and Sergeant deal with a full waiting list. Default = 1 second.
2. Nonzero if the Lieutenant should dump the contents of the queues (lines 7-10). Default = 0, don't print.
3. How long the producer should sleep between each search of the wait area (i.e., before reading each input line after the first). Default = 3 seconds.

Termination

When the input file is empty, the Sergeant terminates, but the barber continues until the last longhair has had his haircut. The Lieutenant continues until both the Sergeant and the Barber have terminated. Look at some of the semaphore operations for ways to do this. Thus, the final output from the Lieutenant should show an equal number of long hairs entering the system and short hairs produced, with an empty waiting room at the end.

Submission Instructions

Submit your code in the usual way, using cs110submit.

• NO HARDCOPY CODE needs to be turned in.
• Submit a README file that describes your overall implementation, including:
  • The number of semaphores and the use of each semaphore,
  • An explanation of any unusual uses of semaphores (e.g., some counts might be in shared memory or in semaphores),
  • How you arrange and use the shared memory (a commented struct or class definition),
  • Your algorithm for managing the 3 lists,
  • Your algorithm for managing the 3 barbershop queues,
  • Your algorithm for how the child processes decide whether (and when) they are done (not just a momentary lull in people entering the barbershop). and
  • A paragraph how your program relates to scheduling and/or virtual memory management in an operating system. (This is not just a coding project. :-) Think about relationships with fixed-size memory areas, priorities, etc.)
• Submit a file named script.txt, containing a listing of a run against the trivial sample input file.

We will either test your program against other input cases, or ask you to demonstrate your program to the graders (procedure to be determined later).

Other Notes

• You MUST use a single array to implement your three queues. The queues must share the 20 slots in the array.
• You MUST manage the barbershop wait area as priority FIFO queues. People DO NOT move to new chairs, they sit in a chair and stay there until it is time to get a haircut. You must use list management to keep track of who is next. You will also need a fourth list to keep track of empty chairs so the producer knows where to seat the next person. The producer MAY NOT find empty seats by scanning the entire array every time somebody arrives.
• The Sergeant, the producer, must also manage the line of people waiting outside the barbershop. He cannot let someone in unless there is a chair in the barbershop (thus, he is in a loop that keeps trying to read input and put a person in the barbershop). Each time he awakes (time defaults to 3, but is a startup parameter), he checks his waiting area (input stream) and seats the next person (only 1 person per wakeup, an officer, NonCom, or grunt) as long as there is room in the barbershop. If there is no room, the Sergeant must block (NO BUSY WAITING) until there is space available in the 20-chair waiting area.
• Remember from the Dining Philosophers project that Turing has a limited number of semaphores and shared-memory descriptors. Be sure to write your code so that it cleans up after itself, and to use ipcs and removeipc to clean up when your code breaks. You will lose points for holding old semaphores and/or shared memory!!!

References:

• Solaris man pages for fork, semctl, and shmctl
• Chapter 3, UNIX Network Programming, W. Richard Stevens. On reserve in the library.
• IPC summary
• If you find other good references, please let me know.

Notes:

We reserve the right to change the problem statement when someone demonstrates the ambiguity of said problem statement.