Question

Modify the reader/writer code so that if a writer shows up, no more readers are admitted until at least one writer is served guaranteeing no starvation.

Answer 1

READERS-WRITERS PROBLEM WITH WRITERS PRIORITY

In this operation

1. A writer request to enter into critical section

2. If allows, it perform writing, otherwise wait

3. If one writer is writing no one can read or write

4. When one writer completes write operation, the processor checks for if there is any other process request for write operation.

   1. If YES, that process get allocated the critical section

   2. if NO, check for read operations requested by the processes

5. Ensures all the write requests are allocated before allocating critical section to the read requests.

For this opeartion

• we use two semaphores

  1. mutex : to ensure mutual exclusion during the operation

  2. wrt : to perform read and write operations

• write count, wc : to check number of process requests write operation. Wc is initialized as 0.

Functions used in this operation

1. wait() : used to decrement the semaphore value.

2. Signal() : used to increment the semaphore value

Program (In question programming language is not mentioned. SO YOU CAN CONSIDER THIS AS A PSEUDO CODE)

do {

// writer requests for critical section

wait(mutex):

// number of writers count increased by 1

wc++;

do {

// loop to continue allocating write processes

if(wc == 1)

wait(wrt);

// this is to ensure that no readers can under if there atleaset one writer

// WRITER PERFOMR WRITE OPERATION

// only one writer can write at a time

wait(mutex); // a writer wants to leave

wc--;

}while(wc != 0);

if(wc == 0)

signal(wrt); //readers can enter

signal(mutex); // writer leaves

}while(true);

Process

1. Writer request to enter into critical section

2. if the request is accepted,

   1. Writer count wc is incremented.

   2. Check it is first writer(wc = 1). If true, it locks the wrt semaphore to block any other readers to enter.

   3. Performs the write operation. Only one writer can perform at a time

   4. After completion, wc is decremented by 1 when one writer leaves.

   5. If wc is not zero perform the write operation again

3. If not accept, it should wait

4. After all write operations completed, signal the wrt which allows other readers can enter