GATE-CS-2014-(Set-2) Question 52

Introduction

This question deals with the concept of process synchronization in operating systems. Process synchronization is a fundamental aspect of an operating system and ensures that multiple processes can share resources and execute concurrently without interfering with each other.

Problem Statement

Consider the following code segment:

Semaphore X = 0, Y = 0, Z = 0;
void process_0()
{
    while (true)
    {
        wait(X);
        print("hello ");
        signal(Y);
        wait(Z);
        print("world\n");
        signal(X);
    }
}
void process_1()
{
    while (true)
    {
        wait(Y);
        print("hey ");
        signal(Z);
    }
}

Here, Semaphore is a synchronization primitive used to implement process synchronization. wait decrements the value of the semaphore and blocks if the value becomes negative. signal increments the value of the semaphore and wakes up a blocked process if there is any.

Assume that the initial value of each semaphore is 0. The above code segment is executed by two concurrent processes P0 and P1. Identify a proper binary semaphore that can replace the semaphores X, Y, and Z to ensure that the output of the program is always "hello world" repeatedly.

Solution

We need to design a synchronization scheme using a binary semaphore that ensures that the output of the program is always "hello world" repeatedly. Binary semaphore, also known as a mutex, can take on only two values, 0 or 1, and can be used to control access to a shared resource.

One possible solution is to use a binary semaphore S, which will act as a mutex between the two processes. Here's the modified code using S:

Semaphore S = 1;
void process_0()
{
    while (true)
    {
        wait(S);
        print("hello ");
        signal(S);
    }
}
void process_1()
{
    while (true)
    {
        wait(S);
        print("world\n");
        signal(S);
    }
}

Here, we have modified the code to use a single binary semaphore S. Process P0 acquires the mutex by calling wait(S) and then prints "hello" followed by releasing the mutex by calling signal(S). Likewise, Process P1 acquires the mutex, prints "world", and then releases the mutex. Since the processes are executing concurrently, the order of execution is not guaranteed, but the use of the semaphore ensures that the output is always "hello world" repeatedly.

Conclusion

In this question, we discussed the use of binary semaphore as a synchronization primitive to ensure process synchronization. We designed a synchronization scheme using a single binary semaphore S that ensures that the output of the program is always "hello world" repeatedly. The solution demonstrates the importance of process synchronization in operating systems and how it is used to ensure that multiple processes can share resources and execute concurrently without interfering with each other.