Classical Problems [87]

• classical problems are simple but represent complex, real problems

• show important features of real problem/solution

• examples from OS and real-time applications

• main points:

• mutual exclusion to critical section code

• synchronized access to shared resources and data

Dining Philosophers [88]

Problem:

• 2 philosophers

• 2 chopsticks (1 pair)

questions

• How can both philosophers eat?

• How to share resources?

answer

• TAKE TURNS USING RESOURCES

Dining Philosophers [89]

• Rule 1: a philosopher thinks.

• Rule 2: a philosopher gets 2 chopsticks (1 pair).

• Rule 3: a philosopher eats.

• Rule 4: there are only 2 chopsticks (1 pair).

• Rule 5: after eating, philosopher puts down 2 chopsticks (1 pair).

demo-OK:

Exercise 7a: Philosopher 1 uses the 2 chopsticks (1 pair) to eat. Then Philosopher 2 uses the 2 chopsticks (1 pair) to eat. Both make progress and the access to the resources (chopsticks) is synchronized.

demo-BAD:

Exercise 7a: Philosopher 1 gets one (1) chopstick. Philosopher 2 gets the other (1) chopstick. Neither can eat. Both are deadlocked.

Dining Philosophers [90]

• each chopstick is a semaphore

• a philosopher waits for access to 2 chopsticks

• a philosopher signals when finished eating

                    while(1) {
                       /* philosopher thinks */
                       pm_wait(chopstick1);
                       pm_wait(chopstick2);
                       /* philosopher eats */
                       pm_signal(chopstick1);
                       pm_signal(chopstick2);
                    }

Burns' Dining Philosophers [91]

Shared Variables:

1.

FORK: semaphore array [0..n-1], initially all available

Code: At p_i in {0,...,n-1}:

do forever

if even(i) then {

wait(FORK_{i+1}) /* left fork */

wait(FORK_i) /* right fork */

}

if odd(i) then {

wait(FORK_i) /* right fork */

wait(FORK_{i+1}) /* left fork */

}

/* Critical region */

signal(FORK_i)

signal(FORK_{i+1})

Producer/Consumer [92]

Problem:

Producer: Consumer:
buffer
data => => data

questions

• What if producer is faster than consumer?

• What if buffer overflows?

• What if consumer is faster than producer?

• What if buffer is empty?

answer

• PRODUCER WAITS FOR NOT FULL

• CONSUMER WAITS FOR NOT EMPTY

Producer/Consumer [93]

• Process 1 is a producer of data.
• Process 2 is a consumer of data.

• Rule 1: the producer puts data in the buffer.

• Rule 2: the buffer holds only 5 numbers.

• Rule 3: the consumer gets data from the buffer.

• Rule 4: the producer waits for the buffer to be not full.

• Rule 5: the consumer waits for the buffer to be not empty.

demo-OK:

Exercise 8a: Producer puts data into buffer; consumer gets data and writes it.

demo-BAD:

Exercise 8b: The producer fills the buffer with 5 numbers, then waits for the consumer to signal that the buffer is not_full. The consumer reads from the buffer, then waits for the producer to signal that the buffer is not_empty. Both are deadlocked.

Producer/Consumer [94]

• producer waits for the buffer to be not full

• producer waits for access to the buffer (mutual exclusion)

• producer signals after access to the buffer (mutual exclusion)

• producer signals that the buffer is not empty

                    while(1) {
                       pm_wait(not_full);
                       pm_wait(sem_buffer);
                       /* put data into buffer */
                       pm_signal(sem_buffer);
                       pm_signal(not_empty);
                    }

Readers/Writer [95]

Problem

many readers OK: => data

one writer OK: <= data

read/write NOT OK: data => <= data

questions

• What if readers are reading data from file?

• What if writer is writing data to file?

answer

• READERS WAIT FOR NO WRITERS

• WRITER WAITS FOR SOLE ACCESS

Readers/Writer [96]

• Process 1 and 2 read data from a file.

• Process 3 writes data to the file.

• Rule 1: if a process reads data, another process can read data.

• Rule 2: if a process writes data, another process cannot read data.

demo-OK:

Exercise 9a: Readers 1 and 2 read from the file and Writer 3 waits.Then, Writer 3 writes to the file and Readers 1 and 2 wait. All make progress and the shared access to the file is synchronized. The readers see a consistent file.

demo-BAD

Exercise 9b: Writer 3 writes to the file before Readers 1 and 2 are finished reading from the file. The readers do not see a consistent file. Writer 3 needs to use a semaphore.

Readers/Writer [97]

• reader waits for writer to finish writing

• reader signals to writer when all readers are finished reading

                    while(1) {
                       pm_wait(sem_readcount);
                       readcount++; 
                       if (readcount==1) pm_wait(sem_wrt);
                       pm_signal(sem_readcount);
                       ... 
                       pm_wait(sem_readcount);
                       readcount--; 
                       if (readcount==0) pm_signal(sem_wrt);
                       pm_signal(sem_readcount);
                    }

• writer waits for access to the file

• writer signals after access to the file

                    while(1) {
                       pm_wait(sem_wrt);
                       /* write to file */
                       pm_signal(sem_wrt);
                    }

Cigarette Smokers [98]

IIICsmoke

Problem:

questions

• What if three products are needed to smoke?

• What if each smoker needs a different product?

• What if agent provides product only in turn?

• How to allocate resources?

answer

• AGENT: SIGNAL and WAIT FOR PRODUCT

• SMOKER: WAIT and SIGNAL FOR PRODUCT

Cigarette Smokers [99]

• Process 1, 2, and 3 are smokers. Process 4 is an agent.
• Rule 1: smokers need 3 products: tobacco, paper, matches.
• Rule 2: Smoker 1 needs tobacco, 2 needs paper, 3 needs matches.
• Rule 3: the agent puts tobacco on the table and Smoker 1 smokes.
• Rule 4: the agent puts paper on the table and Smoker 2 smokes.
• Rule 5: the agent puts matches on the table and Smoker 3 smokes.

demo-OK:

Exercise 10a: Each smoker gets to smoke in turn. All make progress and the access to resources is synchronized.

demo-BAD:

Exercise 10b: Smoker 1 gets to smoke while the other smokers wait for a signal that Smoker 1 is done. But Smoker 1 is waiting for its turn again. All are deadlocked.

Cigarette Smokers [100]

• Smoker 1 waits for tobacco to be supplied by the agent

• Smoker 1 signals to the agent when finished

                    while(1) {
                       pm_wait(tobacco);
                       /* smoke */
                       pm_signal(tobacco);
                    }

• agent signals that tobacco is available

• agent waits for the smoker to finish

                    while(1) {
                       pm_signal(tobacco);
                       pm_wait(tobacco);
                       ... 
                    }

IPC Message: send and receive [101]

• process receives messages from pid

                    while(1) {
                       msg = pm_receive(&pid);
                    }

• process sends messages to pid=7

                    pid=7;
                    while(1) {
                       pm_send(pid,msg++);
                    }

• process sends and receives messages from pid

                    while(1) {
                       msg = pm_receive(&pid);
                       pm_send(pid,msg++);
                    }

Message Demo [102]

• Process 1 waits on a semaphore

• Process 1 sends a message to Process 2

                    pid = 2;
                    while(1) {
                       pm_wait(sem);
                       pm_send(pid,msg);
                    }

• Process 2 signals the semaphore

• Process 2 receives a message from Process 1

demo-OK:

Exercise 11a: Both processes make progress.

demo-BAD:

Exercise 11b: Both processes are deadlocked.

Client/Server [103]

• Process 1 is a server. Process 2 and 3 are clients.

• Rule 1: a client sends a message for action by the server.

• Rule 2: the server receives the message from a client.

• Rule 3: the server sends an answer back to the client.

• Rule 4: the client receives the message from the server.

demo-OK:

Ex12a: Server waits in receiving for a message from a client. Each client sends a message and waits in receiving for an answer. The server receives each message, in turn, and sends back an answer.

demo-BAD:

Ex12b: Server receives both messages but does not send back answers to either client. The clients are waiting for answers and the server is waiting for new messages. All processes are deadlocked.

Client/Server [104]

• a client sends a message for action by the server

• the client receives a message from the server

                    while(1) {
                       pm_send(server_pid,msg);
                       msg=pm_receive(&server_pid);
                    }

• the server receives and sends messages

Ring Network [105]

Ring:

• 8 processes wait for messages on a ring network.

• Rule 1: receive a message.

• Rule 2: message++.

• Rule 3: if the message has gone around the ring, ``finished''.

• Rule 4: else, send the message to the next process on the ring.

Ring Network [106]

demo-OK:

Exercise 13a: All processes are deadlocked, waiting for a message. Send, Process 1, message ``0''. The message goes to all processes on the ring.

demo-BAD:

Exercise 13b: The message does not go to any other processes on the ring. All processes are deadlocked waiting for messages.

• process receives message and sends to next process on ring

                    while(1) {
                       msg=pm_receive(&pid);
                       ...
                       pm_send(nextpid,msg); 
                    }

Star Network [107]

Star:

• 8 processes wait for messages on a star network.

• Process 1 is the center. The others are on the rim.

• Rule 1: receive a message.

• Rule 2: message++.

• Rule 3: rim only: if message not from center, send message to center.

• Rule 4: rim only: if message has gone to all processes, ``finished''.

• Rule 5: center only: send message++ to the remaining processes.

Star Network [108]

demo-OK:

Exercise 14a: All processes are deadlocked, waiting for a message. Send, Process 1, message ``0''. The message goes to all processes on the rim of the star.

demo-BAD:

Exercise 14b: The message does not go to any processes on the rim of the star. All processes are deadlocked waiting for messages.

Star Network [109]

• rim process receives a message and sends to the center process

            while(1) {
              msg=pm_receive(&pid);
              if (pid != center_pid)
                pm_send(center_pid,msg++); 
            }

• center process receives a message and sends to rim processes

            while(1) {
              msg=pm\_receive(&pid);
              msg++;
              for (all rim processes which do not have the message) 
                pm_send(rim_pid,msg++); 
            }