Consider a computer system with multiple shared resource types, with one instance per resource type. Each instance can be owned by only one process at a time. Owning and freeing of resources are done by holding a global lock (L). The following scheme is used to own a resource instance: function OWNRESOURCES(Resource R) Acquire lock L / / a global lock if R is available then Acquire R Release lock L else if R is owned by another process P then Terminate P, after releasing all resources owned by P Acquire R Restart P Release lock L end if end if end function Which of the following choice(s) about the above scheme is/are correct?

Consider a computer system with multiple shared resource types, with one instance per resource type. Each instance can be owned by only one process at a time. Owning and freeing of resources are done by holding a global lock (L). The following scheme is used to own a resource instance: function OWNRESOURCES(Resource R) Acquire lock L / / a global lock if R is available then Acquire R Release lock L else if R is owned by another process P then Terminate P, after releasing all resources owned by P Acquire R Restart P Release lock L end if end if end function Which of the following choice(s) about the above scheme is/are correct? Correct Answer The scheme may lead to starvation., The scheme may lead to live-lock., The scheme ensures that deadlocks will not occur.

Concept:

Livelock:  A situation in which two or more processes continuously change their states in response to changes in the other process(es) without doing any useful work.

Consider the following example 

In this example, if you see both the processes just changing states of their flag variable and none of them can enter into the critical section provided mutual exclusion is satisfied. 

Note:
*Assume that preemption does not occur in executing the statement of inside while loops in the above example.

Explanation:

- OWNRESOURCES(R) function does the following tasks

acquire lock L

• If R is available

acquire resource R 
release lock L

• If R is not available , it is already acquired by a process P

Terminate P and release all resources owned by P.
acquire R.
Restart P
Release L

Option 1: The scheme may lead to starvation.

this is correct.

Let's take an example consider 2 processes (P, Q₁)  initially no other process currently in the System. First Q₁ executes OWNRESOURCES(R) 

• Q1 acquires L
• Q1 acquires R
• Q1 Release L

Now as soon as Q1 finishes Q₂ arrives and executes the same 3 tasks and completes then as soon as Q2 finishes Q₃ arrives and so on process Q's keep arriving in the system and the process P never gets to execute.

so Starvation possible.

Option 2: The scheme may lead to live-lock.

Let's take an example consider 2 processes (P, Q)  initially no other process currently in the System. First P executes OWNRESOURCES(R)

• P acquires L
• P acquires R
•  Release L

immediately after Releasing L, P gets preempted Q starts OWNRESOURCES(R) 

• Q acquires L
• Terminate P and release all resources owned by P.
• acquire R.
• Restart P
• Release L

immediately after Releasing L, Q gets preempted P starts OWNRESOURCES(R) 

• P acquires L
• Terminate Q and release all resources owned by Q.
• acquire R.
• Restart Q
• Release L

and so on the same thing will repeat itself.

This is not Deadlock right. This is Livelock.

Option 3: The scheme ensures that deadlocks will not occur.

This statement is correct as Deadlock not possible. because even if there circular waiting exists one process simply terminates the other processes which hold the resources.

so no hold and wait, so Deadlock will not occur.

Option 4: The scheme violates the mutual exclusion property.

This statement is not correct because every process has to go through the function OWNRESOURCES(R) to own resource and even if a Resource is owned by another process then it will get terminated and restarted; at a time no 2 processes can own a single resource. So Mutual exclusion property is satisfied.