Question

Operating system :

Concurrent processes P0 and P1 use the following C-codes to access a critical section CS:

Void p0() / / process P0

{

while (TURE){

Flag[0]=TURE; turn=1;

While (flag[1]&&(turn==1))

Critical section;

Flag[0]=FALSE;

} }

Void p1() / / process P1

{

while (TURE){

Flag[1]=TURE; turn=0;

While (flag[0]&&(turn==0))

Critical Section (CS);

Flag[1]=FALSE;

} }

where the initial values for the shared variables are:

boolean flag[2] ；

int turn=0;

flag[0]=false; flag[1]=false;

The above implementation of P0 and P1 guarantees ()

A） both mutual exclusion for CS access and bounded-waiting for entry to CS

B） neither mutual exclusion for CS access, nor bounded-waiting (non-starvation) for entry to CS

C） mutual exclusion for CS access, but not bounded-waiting for entry to CS

D） bounded-waiting for entry to CS, but not mutual exclusion for CS access

please provide explanation for your answer.

please only answer id you are sure of the answer thank you.

Answer 1

Answer:Option (A) - both mutual exclusion for CS access and bounded-waiting for entry to CS

Explanation:
Here we have two shared variables:

• boolean flag[2], which represents whether a process is interested to go into the critical section or not.
• int turn determines the process whose turn is to enter the critical section.

When a process wants to execute its critical section, it sets its flag = true and turn as the index of the other process. This means that the process wants to execute but it will allow the other process to run first. The process performs busy waiting until the other process has finished its own critical section. If the process desires to acquire the critical section, then, it gets the critical section and passes the chance to the 2nd process. If it does not desire to get the critical section then the while loop breaks and the 1st process gets the chance.

Busy Waiting.
Flag[0]=TRUE; turn=1;
While (flag[1] && (turn==1)); // P1_gate

P₀ and P₁ can never be in the critical section at the same time (MUTUAL EXCLUSION): If P₀ is in its critical section, then flag[0] is true. In addition, either flag[1] is false (meaning P₁ has left its critical section), or turn is 0 (meaning P₁ is just now trying to enter the critical section, but graciously waiting), or P₁ is at the label P1_gate (trying to enter its critical section, after setting flag[1] to true but before setting turn to 0 and busy waiting). So if both processes are in their critical sections then we conclude that the state must satisfy flag[0] and flag[1] and turn = 0 and turn = 1. No state can satisfy both turn = 0 and turn = 1, so there can be no state where both processes are in their critical sections.

Bounded waiting says that a bound must exist on the number of times that other processes are allowed to enter their critical sections after a process has made a request to enter its critical section and before that request is granted.

Here, the Peterson's solution is considered strict alternation so, alternatively, process[0] and process[1] will get access to the critical section. Here bounded waiting won't be satisfied in case e.g. some process gets C.S. repeatedly starving other processes but this situation is not possible because of a strict alternation.

By using 'turn' variable bounded waiting is ensured.

Note:If you have any doubts or queries please comment I willget back to you and clarify.