PROBLEM A:

Little rascals, Spanky, Alfalfa, and Darla are sitting around a table waiting to eat an ice cream sundae. To eat a sundae, you need three things:jimmies, ice cream, chocolate sauce.

- Spanky has ice cream and chocolate sauce.
- Alfalfa has jimmies and chocolate sauce, and
- Darla has jimmies and ice cream
Initially all three kids are "blocked."
Their lovely teacher, Miss Crabtree, has an infinite supply of each item. Miss Crabtree randomly places one item on the table, unblocking the kid who needs it, and then Miss Crabtree blocks (waits). The kid who needs that item takes it and eats. Only one item may be placed on a table at any time. Each rascal waits for the one item he/she needs then consumes some ice cream for a random amount of time unblocking Miss Crabtree when he/she is done eating. Miss Crabtree then puts another item on the table and the scenario continues.

Write a program that synchronizes the threads such that deadlock does not occur and no little rascal starves. The output should specify which rascal is eating.

PROBLEM B:

Consider an orchestra conductor and a group of musicians. The musicians play independently but are coordinated by the conductor. For each measure of music indicated by the conductor's baton, the musicians play a set of notes. The musicians do not move onto the next measure until indicated by the conductor's baton. The Orchestra is called the Narcolepsy Symphony Orchestra because occasionally a musician falls asleep. When this happens the rest of the musicians continue playing. When the sleeping musician wakes up, the musician begins playing again with the orchestra.
Here are some guidelines:
- Simulate 100 measures
- Simulate 3 to 10 musicians
- use one thread per musician. The thread doesn't die at the end of the measure... it lives for the duration of the piece.
- use semaphores as the synchronization mechanism not pthread_join (since musician threads live across measures)
- for each measure, there is a 25% chance that the musician will fall asleep
- when a musician sleeps, it is for a random number of measures (say 1-5)... this is sleep amount is unknowable to the conductor.. the musician simply "wakes up" when it is ready to start playing again.
- use the sleep method sleep() method to simulate sleep, sleeping players do a sleep(random 1-5) seconds to simulate sleeping.
- do not to use sleep as a synchronization mechanism
- in addition to outputting that it is playing, the musician thread should sleep(1) to simulate playing a measure...
- provide feedback for each measure that looks something like this:
MEASURE 1:
Musician 3 playing
Musician 4 playing
Musician 1 playing
Musician 2 playing
MEASURE 2:
Musician 1 playing
Musician 3 playing
Musician 4 playing
MEASURE 3:
Musician 4 playing
Musician 1 playing
Musician 3 playing
MEASURE 4:
Musician 3 playing
Musician 2 playing

Note that: Musician 2 is sleeping in Measure 2 & 3 and Musicians 3 & 1 are sleeping in Measure 4

PROBLEM C:

Enhance the reader/writer problem we discussed in class using N readers and 1 writer so that the writer will not suffer from starvation.
Simulate readDB() and writeDB() using sleep().
Ensure that the delay for readDB() is much shorter than writeDB().

PROBLEM D:

Consider a doctor's office with a very overworked doctor.

The doctor has an examining room and a waiting room with a number of chairs in it. When the doctor finishes with a patient, the patient leaves and the doctor goes to the waiting room to see if there are other patients waiting. If there are, she brings one of them back to the examining room and examines the patient. If there are no patients waiting, she returns to her examining room, lies down on the examining table and goes to sleep.

Each patient (or I should say impatient), when he arrives, knocks on the examining room door to see what the doctor is doing. If the doctor is sleeping, then the patient wakes her up and enters the examining room. If the doctor is performing an examination, then the patient goes to the waiting room. If there is a free chair in the waiting room, the patient sits in it and waits his turn. If there is no free chair, then the patient leaves.

Assume there are 10 chairs in the waiting room. The doctor must be a thread. Each patient must be a thread, assume 13 patients, each running in an infinite loop to simulate arriving at the office, being examined (or not), then leaving... then repeat.