# Reading Materials:

* chapter 6.1-6.7
* chapter 7.1-7.6

# Weekly Exercise:

* 6.10: The implementation of mutex locks provided in Section 6.5 suffers from busy waiting. Describe what changes would be necessary so that a process waiting to acquire a mutex lock would be blocked and placed into a waiting queue until the lock became available.
* 6.14 Consider the code example for allocating and releasing processes shown in Figure 6.23.
  * a. Identify the race condition(s).
  * b. Assume you have a mutex lock named ```mutex``` with the operations ```acquire()``` and ```release()```. Indicate where the locking needs to be placed to prvent the race condition(s).
  * c. Could we replace the integer variable ```int number_of_processes = 0``` with the atomic integer ```atomic_t number_of_processes = 0``` to prevent the race condition(s)?
* 6.17 Show how to implement the ```wait()``` and ```signal()``` semaphore operations in multiprocessor environments using the ```test_and_set()``` instruction. The solution should exhibit minimal busy waiting.
* 6.22 Discuss the tradeoff between fairness and throughput of operations in the readers-writers problem. Propose a method for solving the readers-writers problem without causing starvation.

* 7.8 Consider a system consisting of **m** resources of the same type being shared by **n** processes. A process can request or release only one resource at a time. Show that the system is deadlock free if the following two conditions hold:
  * a. The maximum need of each process is between one resource and **m** resources.
  * b. The sum of all maximum needs is less than **m + n**

* 7.9 Consider the version of the dining-philosophers problem in which the chopsticks are placed in the center of the table and any two of them can be used by a philosopher. Assume that requests for chopsticks are made one at a time. Describe a simple rule for determining whether a particular request can be satisfied without causing deadlock giventhe current allocation of chopsticks to philosophers.
* 7.10 Consider again the setting in the preceding question. Assume now that each philosopher requires three chopsticks to eat. Resource requests are still issued one at a time. Describe some simple rules for determining whether a particular request can be satisfied without causing deadlock given the current allocation of chopsticks to philosophers.

* 7.12 Consider the following snapshot of a system:

|          | Allocation | Max      |
| -------- | ---------- | -------- |
|          | A B C D    | A B C D  |
| $P_0$    | 3 0 1 4    | 5 1 1 7  |
| $P_1$    | 2 2 1 0    | 3 2 1 1  |
| $P_2$    | 3 1 2 1    | 3 3 2 1  |
| $P_3$    | 0 5 1 0    | 4 6 1 2  |
| $P_4$    | 4 2 1 2    | 6 3 2 5  |


Using the banker's algorithm, determine whether or not each of the following states is unsafe. If the state is safe, illustrate the order in which the process may complete. Otherwise, illustrate why the state is unsafe.
  * a) **Available** = (0, 3, 0, 1)
  * b) **Available** = (1, 0, 0, 2)

Figure 6.23 - Allocating and releasing processes

```
#define MAX_PROCESSES 255
int number_of_processes = 0

/* the implementation of fork() calls this function */
int allocate_processes() {
 int new_pid;

 if (number_of_processes == MAX_PROCESSES)
  return -1;
 else {
  /* allocate necessary process resources */
  ++number_of_processes;

  return new_pid;
 }
}

/* the implementation of exit() calls this function */
void release_processes() {
 /* release process resources*/
 --number_of_processes;
}
```