# Homework 3 – Process Synchronization - Solutions

## COP 4610/CGS5765, Introduction to Operating Systems, Fall 2003, Florida State University

¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾

Points: 100 points

Due: Week 9, Tuesday, October 21, 2003

Special Note: This assignment is due at the beginning of the class. No late submission for this assignment will be accepted as the solution will be made available during the class time.

1.      (15 pnts) Problem 4 in the textbook on pages 322 and 323.

a.       This solution forces the two cooperating processes to alternate visits to the critical section. Thus, there is an implicit timing dependency between the two processes, e.g., if one is much slower than the other, then the fast process will have to synchronize with the slow process on each cycle through the loop. Also, if either stops then the other can also only run through the critical section at most one more time

b.      This algorithm does not solve the problem since it might allow both processes to be in the critical section at the same time. Suppose that the two processes "simultaneously" execute the while-test; they will both pass the test, set their respective flag and enter the critical section. The algorithm is not safe.

c.       This algorithm attempts to resolve the problem described in part (b) by setting the flag before attempting to test the opposite flag. Now, if both processes set their respective flag variables "simultaneously," then the two processes are deadlocked.

2.      (15 pnts) Problem 5 in the textbook on page 323.

Then, if all the buffers were to become empty at one time, the consumer would obtain the mutex semaphore and block on the full semaphore, while holding the mutex semaphore. This is a deadlock situation because the consumer holds all the empty buffers and requests a full one, but the producer cannot create a full buffer without first obtaining an empty buffer. The order of appearance of the P operations is significant.

3.      (20 pnts) Problem 6 in the textbook on page 323.

Here is a solution:

`Time Action         Result`
` `
`0    Reader 1 arrives`
`1    Reader 1 executes         P(read_block)   read_block = 0`
`2    Reader 1 executes P(s1)  s1 = 0`
`3    Writer 1 arrives`
`4    Writer 1 waits at p(read_block)`
`5    Reader 2 arrives`
`6    Reader 2 waits at p(read_block)`
`7    Reader 1 executes v(s1)  s1 = 1`
`8    Reader 1 executes v(read_block)          read_block = 1`
`9    Reader 2 may now occur          Writer 1 did not have priority`

4.      (15 pnts) Problem 8 in the textbook on pages 323 and 324.

This is Peterson's software solution (Information Processing Letters, vol. 12, pp. 115-116, 1981) to the critical section problem. The argument for its correctness is paraphrased from the original paper as follows:

First, only one process at a time should be allowed to enter its critical section (mutual exclusion).

For both processes to be in their critical sections, then they would have had to simultaneously set their own flag to TRUE, that is, flag[0] = flag[1] = TRUE. Thus, the two processes are simultaneously attempting to enter their critical section. Also, process 0 (process 1) only enters its critical section after it has set the turn variable to 1 (0) and if flag[1] (flag[0]) is FALSE or turn is 0 (1 in the case of process 1). But only one of the processes could have last set the value of turn, so it is either 0 or 1 at any instant. Suppose turn is 0; then process 1 will pass the while test and continue to evaluate the expression; process 0 will set turn to 1 (if it had not yet executed the statement, which means that process 1 will evaluate the expression FALSE on its next attempt), or it will evaluate the expression FALSE and will enter the critical section. Only one of the processes will be allowed to enter its critical section.

Second, once a process indicates a need to enter into its critical section, it cannot be postponed indefinitely.

A process can only be blocked from entering its critical section at the while loop. Thus, if process 0 is blocked, then it finds flag[1] TRUE and turn set to 1. Process 1 must be in its critical section, otherwise flag[1] would be FALSE. If process 1 is attempting to enter its critical section, then either turn is 0 or 1, thus one or the other is allowed to proceed. If it is 1, then process 1 will enter the critical section (or it is already in its critical section). In either case, process 1 will eventually exit its critical section and set flag[1] to FALSE. Process 0 will then fail the while test and enter the critical section. Notice that if process 1 exits the critical section and then attempts to reenter it it will block itself from competing with process 0 by setting turn to 0.

Third, after a process requests entry into its critical section, a bounded number of other processes may be allowed to enter before the original process enters the critical section. This follows by the same argument used for condition (2).

5.      (20 pnts) Problem 10 in the textbook on pages 324 and 325.

`customer() {`
`  while(TRUE) {`
`    customer = nextCustomerArrives();`
`    p(mutex)`
`    if(emptyChairs < 0) { V(mutex); continue;}`
`    V(mutex);`
`    P(chair);`
`      P(mutex);`
`        emptyChairs--;`
`        takeChair(customer);`
`      V(mutex);`
`    V(waitingCustomer);`
`  }`
`}`
` `
`barber() {`
`  while(TRUE) {`
`    P(waitingCustomer);`
`      P(mutex);`
`        emptyChairs++;`
`        customer = takeCustomer();`
`      V(mutex);`
`    V(chair);`
`  }`
` `
`semaphore mutex = 1, chair = N, waitingCustomer=0;`
`int emptyChairs = N;`
`fork(customer, 0);`
`fork(barber, 0);`
`}`

6.      (15 pnts) Problem 3 in the textbook on page 360.

`monitor semaphore {`
`private:`
`  int count = 1;   /* set to the initial value of the semaphore */`
`  condition hold;`
`public:`
`  P() {count--; if(count < 0) hold.wait;};`
`  V() {count++; hold.signal:};`
`};`