Deadlocks · Operating Systems · GATE CSE

Consider the following threads, T₁, T₂ and T₃ executing on a single processor, synchronized using three binary semaphore variables, S₁, S₂ and S₃, operated upon using standard wait( ) and signal( ). The threads can be context switched in any order and at any time.

Which initialization of the semaphores would print the sequence BCABCABCA....... ?

Which of the following statements is/are TRUE with respect to deadlocks?

$P=\left\{P_1, P_2, P_3, P_4\right\}$ consists of all active processes in an operating system.

$R=\left\{R_1, R_2, R_3, R_4\right\}$ consists of single instances of distinct types of resources in the system.

The resource allocation graph has the following assignment and claim edges.

Assignment edges: $R_1 \rightarrow P_1, R_2 \rightarrow P_2, R_3 \rightarrow P_3, R_4 \rightarrow P_4$ (the assignment edge $R_1 \rightarrow P_1$ means resource $R_1$ is assigned to process $P_1$, and so on for others) Claim edges: $P_1 \rightarrow R_2, P_2 \rightarrow R_3, P_3 \rightarrow R_1, P_2 \rightarrow R_4, P_4 \rightarrow R_2$ (the claim edge $P_1 \rightarrow R_2$ means process $P_1$ is waiting for resource $R_2$, and so on for others) Which of the following statement(s) is/are CORRECT?

Consider a multi-threaded program with two threads T1 and T2. The threads share two semaphores: s1 (initialized to 1) and s2 (initialized to 0). The threads also share a global variable x (initialized to 0). The threads execute the code shown below.

// code of T1

wait(s1);

x = x + 1;

print(x);

wait(s2);

signal(s1);

// code of T2

wait(s1);

x = x + 1;

print(x);

signal(s2);

signal(s1);

Which of the following outcomes is/are possible when threads T1 and T2 execute concurrently?

Consider the following pseudocode, where S is a semaphore intialized to 5 in line#2 an counter is a shared variable intialized to 0 in line#1. Assume that the increment operation in line#7 is not atomic.

1. int counter = 0;

2. Semaphore S = init(5);

3. void parop(void)

4. {

5. wait (S);

6. wait (S);

7. counter++;

8. signal (S);

9. signal (S);

10. }

If five threads execute the function parop concurrently, which of the following program behavior (s) is/are possible?

Consider a state of the system with the Allocation matrix as shown below, and in which $$3$$ instances of $$E$$ and $$3$$ instances of $$F$$ are the only resources available.

From the perspective of deadlock avoidance, which one of the following is true?

$$\,\,\,\,\,\,\,{\rm I}.$$ $$\,\,\,\,\,\,$$ Processes should acquire all their resources at the beginning of execution. If
$$\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,$$ any resource is not available, all resources acquired so far are released
$$\,\,\,\,\,{\rm II}.$$ $$\,\,\,\,\,\,$$ The resources are numbered uniquely, and processes are allowed to request
$$\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,$$ for resources only in increasing resource numbers
$$\,\,\,{\rm III}.$$ $$\,\,\,\,\,\,$$ The resources are numbered uniquely, and processes are allowed to request
$$\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,$$ for resources only in decreasing resource numbers
$$\,\,\,{\rm IV}.$$ $$\,\,\,\,\,\,$$ The resources are numbered uniquely. A process is allowed to request only
$$\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,$$ for a resource with resource number larger than its currently held resources

Which of the above policies can be used for preventing deadlock?

semaphore n = 0;
semaphore s = 1;
void producer()
{
    while(true)
    {
     produce();
     semWait(s);
     addToBuffer();
     semSignal(s);
     semSignal(n);
    }
}

void consumer()
{
   while(true)
   {
    semWait(s);
    semWait(n);
    removeFromBuffer();
    semSignal(s);
    consume();
   }
}

REQ1: P0 requests 0 units of X, 0 units of Y and 2 units of Z
REQ2: P1 requests 2 units of X, 0 units of Y and 0 units of Z

if (i%2==0) {
  if (i < n) request Ri;
  if (i+2 < n) request Ri+2 ;
}
else {
  if (i < n) request Rn-i;
  if (i+2 < n) request Rn-i-2;
}