Counting Semaphores MCQ Quiz in తెలుగు - Objective Question with Answer for Counting Semaphores - ముఫ్త్ [PDF] డౌన్‌లోడ్ కరెన్

Explanation:

The key statement in the above code is wait (b). It will keep the remaining processes blocked until value on count becomes n. Once, the value of count = n, signal (b) would be executed and then a process can enter the code section Q. Thus, none of the process will execute Q until every process has executed code section P.

Stepwise Explanation:

Initialization:  a=1, b=0, count= 0

There are n processes say, P₁, P₂, P₃, ……………., P_n.

Let’s assume P1 has executed successfully the code section P and encounters the statements:

wait (a);      

Now, ‘a’ becomes 0, so all the subsequent processes are blocked.

b= 0, count= 0.

count=count+1 ;                          [ a=0, b=0, count=1]

if (count==n) signal (b) ;              [if condition not true, so statement will not be executed]

signal (a);                                        [a= 1, b=0, count= 1. Other processes can now execute Wait(a)]

wait (b) ;                                [ b= -1, therefore P1 also gets blocked and statement would not be executed]

signal (b);                             

This statement would only run if its preceding statement is executed, which in turn would only be executed if (count==n). Therefore, none of the process would execute Q until every process has successfully executed code section P.

Concepts:

V(S): Signal will increment the semaphore variable, that is, S++. 

P(S): Signal will decrement the semaphore variable., that is, S--. 

Data:

Initial counting semaphore = x

Signal operation = 12 V

Wait operation = 20 P

Since at least 1 process in blocked state

Final counting semaphore (F) = -1

Formula:

F ≥ x + 20P + 12V

Calculation:

-1 ≥ x + 20(-1) + 12(+1)

∴ x ≤ 7

Therefore, largest value of initial semaphore count is 7

Initially S = 0

If P1 executes infinitely

Output: 101010101010

If P1 executes V(S), S = 1 then P2 can execute 

then P2 can execute infinitely

Output 010101010

To get the third option's output here P1 will execute first V(S), S=1 then P1 execute and print 1 0,

after printing 1 and 0 we execute P2 and P(S), S=0 then print 0 1 and because of V(S), S=1 and we can similarly start for P1.

Output will be 100110011001.

To get the fourth option's output  here P2 will execute first and then P1 will execute after and produces output as:-

 011001100110

Similarly, other outputs could be produced.

Tips and Tricks:

If you look carefully every possible combination of 10 and 01 is possible with this code:

Concepts:

V(S): Signal will increment the semaphore variable, that is, S++.

P(S): Wait will decrement the semaphore variable., that is, S--.

Data:

Initial counting semaphore = I = 10

Wait operation = 6 P

Signal operation = 4 V

Final counting semaphore = F

Formula:

F = I + 6 × P + 4 × V

Calculation:

F = 10 + 6 × (-1) + 4(+1)

∴ F = 8

the resulting value of the semaphore is 8

Concepts:

V(S): Signal will increment the semaphore variable, that is, S++. 

P(S): Signal will decrement the semaphore variable., that is, S--. 

Data:

Initial counting semaphore = x = 1

Signal operation = 11 V

Wait operation = 17 P

n process in blocked state

Final counting semaphore (F) = -n

Formula:

n = x + 13P + 5V

Calculation:

n = 1 + 13(-1) + 5(+1)

∴ n = -7

Concepts:

V(S): signal operation will increment the semaphore variable, that is, S++. 

P(S): wait operation will decrement the semaphore variable., that is, S--. 

Calculation:

Initial counting semaphore (I) = x

Signal operation = 14 V

Wait operation = 23 P

Final counting semaphore (F) = -3

F = x + 14V + 23P

-3 = x + 14(+1) + 23(-1)

The correct answer is both (1) and (2).

Key Points

• Semaphores are a synchronization mechanism used to control access to a common resource in a concurrent system such as a multitasking operating system.
• They are primarily used to solve the problems of mutual exclusion and process synchronization.
• Mutual exclusion ensures that only one process can access the critical section of code at a time, preventing race conditions.
• Process synchronization ensures that processes or threads are properly synchronized to avoid issues like deadlocks and ensure correct sequence of execution.

The correct answer is entry section, exit section, remainder section

Key PointsThe critical section problem is a set of rules or protocols for managing concurrent access to a resource that is shared among several processes. The protocols define that:

• Each process must ask permission to enter the critical section in the "entry section" code.
• It then executes in the "critical section" where it has exclusive access to the shared resource.
• Once it finishes execution in the critical section, it enters the "exit section" code where it signals that it has finished with the shared resource.
• The process then enters the "remainder section" code where it executes the non-critical part of its code that doesn't involve the shared resource.

So, the flow is: Entry section -> Critical section -> Exit section -> Remainder section.

Concept:

Semaphore is used to solve the problem of process synchronization. A semaphore is a variable that has an integer value upon which two operations are defined wait and signal, which helps in solving the critical section problem.

Explanation:

Wait operation:

It decrements the semaphore value. If the value becomes negative, then the process executing the wait is blocked.

Pseudocode : 

wait(s)

{

while (s

s= s-1

}

Signal operation: 

It increments the semaphore value. If value is not positive, then a process blocked by wait operation is unblocked.

Pseudocode:

signal(s)

{

 s= s+1

}

Hence the correct answer is option 2

Mistake Points

Option 1 and 2  both are correct.

Concepts:

V(S): Signal will increment the semaphore variable, that is, S++.

P(S): Signal will decrement the semaphore variable., that is, S--.

Data:

Initial counting semaphore = I = 12

Wait operation = 9 P

Signal operation = 3 V

Final counting semaphore = F

Formula:

F = I + 9 × P + 3 × V

Calculation:

F = 12 + 9 × (-1) + 3(+1)

∴ F = 6

the resulting value of the semaphore is 6