Operating System Concepts Chapter 5.4

10 Questions

What is the purpose of the signal(rw_mutex) in the reader process?

To wake up a waiting writer

What happens when a reader process encounters a wait(mutex) for the first time?

It waits for the mutex to be released

What is the main difference between the first and second variations of the readers-writers problem?

The way starvation is handled

What is the purpose of the semaphore chopstick in the dining-philosophers problem?

To synchronize access to the chopsticks

What is the problem with the dining-philosophers problem algorithm?

It is prone to deadlock

What happens when a philosopher picks up two chopsticks?

It can eat immediately

What is the purpose of the wait(chopstick[i]) in the dining-philosophers problem algorithm?

To wait for the philosopher's right neighbor to release a chopstick

What is the common theme among the readers-writers problem and the dining-philosophers problem?

Synchronization of access to shared resources

What is the significance of the read_count variable in the readers-writers problem?

It represents the number of readers currently accessing the shared object

What is the solution to the readers-writers problem in some systems?

Using kernel-provided reader-writer locks

Study Notes

Producer-Consumer Problem

A solution to the producer-consumer problem involves using an integer counter to keep track of the number of full buffers.
The producer increments the counter after producing a new buffer, and the consumer decrements the counter after consuming a buffer.

Race Condition

A race condition occurs when the execution of two or more processes overlaps, causing unexpected results.
In the context of the producer-consumer problem, a race condition can occur when the producer and consumer access the shared counter simultaneously.

Critical Section Problem

The critical section problem involves designing a protocol to allow multiple processes to access a shared resource without conflicts.
Each process has a critical section of code that must be executed exclusively, ensuring that no other process can access the shared resource simultaneously.
The critical section problem can be solved using a protocol that allows processes to request permission to enter the critical section and ensures that only one process can access the shared resource at a time.

Solution to Critical-Section Problem

One solution to the critical-section problem involves using a shared variable turn to indicate which process can enter the critical section.
Each process waits until turn equals its process number before entering the critical section.
After finishing the critical section, the process sets turn to the next process number.

Solution using Test-and-Set()

Another solution to the critical-section problem involves using a shared Boolean variable lock and the test_and_set() function.
The test_and_set() function atomically sets lock to TRUE if it is FALSE, and returns the old value of lock.
A process waits until lock is FALSE before entering the critical section, and sets lock to TRUE to prevent other processes from entering.

Semaphore

A semaphore is a variable that can only be accessed using two indivisible operations: wait() and signal().
wait() decrements the semaphore value, and if the value is negative, the process blocks.
signal() increments the semaphore value, and if a process is blocked, it is awakened.

Deadlock and Starvation

Deadlock occurs when two or more processes are waiting indefinitely for an event that can only be caused by one of the waiting processes.
Starvation occurs when a process is indefinitely blocked due to a semaphore.
Priority inversion is a scheduling problem that occurs when a lower-priority process holds a lock needed by a higher-priority process.

Classical Problems of Synchronization

The bounded-buffer problem involves synchronizing access to a finite buffer by multiple producers and consumers.
The readers-writers problem involves synchronizing access to a shared resource by multiple readers and writers.
The dining-philosophers problem involves synchronizing access to a shared resource (chopsticks) by multiple philosophers.