Operating System Question & Answer

---

( Suggestion : Find the question by search page and keep refreshing the page for updated content )

---

Q.1 a)How can you differentiate general purpose operating system and real time operating system on the basis of Application, Process kernel’s operation?

Answer :

General Purpose Operating System (GPOS) and Real-Time Operating System (RTOS) can be differentiated based on their application and process kernel’s operation. Here’s a breakdown of the key distinctions:

1. Application:
   • GPOS: General-purpose operating systems are designed to cater to a wide range of applications and use cases. They prioritize providing a user-friendly environment and support for various applications, including office productivity, multimedia, web browsing, etc.
   • RTOS: Real-time operating systems are primarily used in time-critical applications where precise and predictable timing is crucial. They are commonly found in industries such as aerospace, automotive, industrial automation, and medical devices.
2. Process Kernel’s Operation:
   • GPOS: In a GPOS, the process kernel operates on a pre-emptive multitasking model, where tasks are assigned priorities, and the operating system schedules and switches between them based on these priorities. Time deadlines are not typically a primary concern in task scheduling.
   • RTOS: RTOSs use a real-time kernel that provides deterministic and predictable timing behavior. They employ a variety of scheduling algorithms, such as fixed-priority scheduling, rate-monotonic scheduling, or earliest deadline first scheduling, to ensure critical tasks meet their deadlines. Real-time kernels focus on minimizing interrupt latency and providing timely responses.
3. Responsiveness and Latency:
   • GPOS: GPOSs prioritize responsiveness to user interactions and provide a good overall user experience. However, they might have higher latency in responding to external events due to their scheduling algorithms and the presence of background tasks and services.
   • RTOS: RTOSs excel in providing low-latency responses to time-critical events. They ensure that tasks with higher priority are immediately serviced, minimizing the time between event occurrence and response.
4. System Performance:
   • GPOS: General-purpose operating systems are designed to balance system performance across a wide range of applications and hardware configurations. They often provide features such as virtual memory management, advanced file systems, and extensive device driver support.
   • RTOS: RTOSs prioritize determinism and minimal overhead. They have a smaller memory footprint, lower context switch times, and reduced interrupt latency, enabling them to respond quickly to critical events..

b) A program consists of single loop that executes 40 times. The loop contains a computation that consumes 40 ms of CPU time followed by an IO that lasts 160 ms. The Program is executed in a multiprogramming OS wit negligible overhead. Compute the elapsed time of the program for the following three cases.
i) The program has the highest priority in the system.
ii) The program is multi programmed with 3 other programs and it has the lowest priority.
iii) The program is multi programmed with 5 other programs and it has the lowest priority.

Answer :

To compute the elapsed time of the program for the given cases, we need to consider the time taken by the computation and I/O operations within the loop, as well as the impact of multiprogramming. Let’s calculate the elapsed time for each case:

Case 1: Single-Threaded Execution In this case, the program runs without any concurrency, and each iteration of the loop executes sequentially.

Elapsed time = (Computation time + I/O time) * Number of iterations
Computation time = 40 ms I/O time = 160 ms Number of iterations = 40
Elapsed time = (40 ms + 160 ms) * 40 = 200 ms * 40 = 8000 ms = 8 seconds

Case 2: Multi-Threaded Execution (Ideal Concurrency) Assuming ideal concurrency, the computation and I/O can overlap perfectly, allowing the program to execute efficiently.

Elapsed time = Maximum(Computation time, I/O time) * Number of iterations
Computation time = 40 ms I/O time = 160 ms Number of iterations = 40
Elapsed time = Max(40 ms, 160 ms) * 40 = 160 ms * 40 = 6400 ms = 6.4 seconds

Case 3: Multi-Threaded Execution (No Overlapping) In this case, the computation and I/O cannot overlap, as the program is executed in a multiprogramming OS with negligible overhead. Each iteration completes before moving on to the next.

Elapsed time = (Computation time + I/O time) * Number of iterations
Computation time = 40 ms I/O time = 160 ms Number of iterations = 40
Elapsed time = (40 ms + 160 ms) * 40 = 200 ms * 40 = 8000 ms = 8 seconds

---

Q.2 a) Identify and fix the issues in the following C++ code snippet. (in the context of OS course)

This is a static function returning a singleton object instance of the Downloader class.

static Downloader *getInstance()
{
if (s_instance != NULL) {
s_instance = new Downloader();
}

Answer :

Here are the issues in the provided code snippet:

Missing variable declaration: The variable s_instance is not declared anywhere in the code snippet. You should declare it as a static member variable of the Downloader class.

Incomplete if statement: The if statement is empty, and it does not have any condition or code block. You need to add a condition to check whether s_instance is already initialized or not.

Memory leak: If the s_instance is already initialized, the code does not clean up the memory allocated for the new Downloader instance. You should delete the previously allocated memory before assigning a new instance.

Incomplete function: The code does not return the instance of the Downloader class. You should add a return statement to return the s_instance.

Here’s the corrected code snippet:

class Downloader {
private:
static Downloader *s_instance;

// Private constructor to prevent instantiation
Downloader() {}

public:
static Downloader *getInstance() {
if (s_instance == nullptr) {
s_instance = new Downloader();
}
return s_instance;
}
};

// Initialize the static member variable
Downloader *Downloader::s_instance = nullptr;

b) Consider the Producer and Consumer problem in which the buffer size is 5. Apply the Semaphore synchronization tool to find the status of the producer/ consumer for the following cases:

i.Initially the buffer is empty. Consumer has tried to consume a product now
ii. After some time, the Producer has placed 5 products in the buffer. He/ She is trying to place one more product into the buffer.
iii. For the continuation above (ii), the consumer tries to consume a product

Answer :

To apply the Semaphore synchronization tool to the Producer and Consumer problem with a buffer size of 5, let’s assume we have two semaphores:

1. empty: Indicates the number of empty slots in the buffer.
2. full: Indicates the number of filled slots in the buffer.

We also need mutual exclusion (mutex) to protect the critical sections of code.

Now let’s analyze the status of the producer and consumer in the given scenarios:

i. Initially, the buffer is empty. The consumer has tried to consume a product now.

• The consumer checks the “full” semaphore to see if there are any products in the buffer. Since the buffer is empty, the “full” semaphore value will be 0, and the consumer will block until there is at least one product in the buffer.

ii. After some time, the producer has placed 5 products in the buffer. He/She is trying to place one more product into the buffer.

• The producer checks the “empty” semaphore to see if there is an empty slot in the buffer. Since the buffer is full (5 products), the “empty” semaphore value will be 0, and the producer will block until there is an empty slot in the buffer.

iii. For the continuation of the scenario in (ii), the consumer tries to consume a product.

• The consumer checks the “full” semaphore to see if there are any products in the buffer. Since there are 5 products in the buffer, the “full” semaphore value will be 5, indicating that there are filled slots available for consumption.
• The consumer also acquires the mutex to ensure exclusive access to the critical section.
• The consumer consumes a product from the buffer.
• After consuming the product, the consumer releases the mutex and signals the “empty” semaphore to increment its value by 1, indicating that an empty slot is available for the producer to produce more products.

---

Q.3 ) Assume that a system has a single processor to process multiple processes but only one process at a particular time. There are 6 processes (P1, P2, P3, P4, P5 and P6) waiting in the Ready queue to execute. Their arrival times, burst times and priorities are tabulated as follows in milliseconds:

Process ID	Arrival Time	Burst Time	Priority
P1	5	6	5
P2	6	7	12
P3	8	5	7
P4	4	5	1
P5	6	10	12
P6	0	3	2

a). Which algorithm will you suggest out of SJN, Priority Scheduling and Round Robin Scheduling algorithm with quantum time is 3 ms? Why?

Answer :

To determine the most suitable scheduling algorithm among Shortest Job Next (SJN), Priority Scheduling, and Round Robin (RR) with a quantum time of 3 ms, let’s evaluate each algorithm based on the given arrival times, burst times, and priorities:

1. Shortest Job Next (SJN) Scheduling Algorithm:
   • P4 has the shortest burst time of 5 ms, followed by P3 with 5 ms, P6 with 3 ms, P1 with 6 ms, P2 with 7 ms, and P5 with 10 ms.
   • Advantages: SJN minimizes the average waiting time and turnaround time for processes with shorter burst times.
   • Disadvantages: Processes with longer burst times may experience increased waiting time and possible starvation.
2. Priority Scheduling Algorithm:
   • P4 has the highest priority of 1, followed by P6 with 2, P1 with 5, P3 with 7, P2 with 12, and P5 with 12.
   • Advantages: Priority scheduling allows prioritization of important or time-critical processes.
   • Disadvantages: Lower-priority processes may experience increased waiting time and potential starvation.
3. Round Robin (RR) Scheduling Algorithm with a quantum time of 3 ms:
   • All processes will be assigned a time quantum of 3 ms.
   • The order of execution will depend on the arrival times and the number of timeslices required for each process to complete.
   • RR provides fair CPU time sharing among processes but may have higher context switching overhead.

Based on the given information, and considering both burst times and priorities, I would recommend using the Priority Scheduling algorithm. This is because the priorities assigned to processes may indicate their relative importance or criticality. However, it’s important to note that the choice of the algorithm ultimately depends on the specific requirements and characteristics of the system.

b) Find the average turnaround time for each method

Answer :

To find the average turnaround time for each method, we need to calculate the turnaround time for each process and then find the average. The turnaround time is the time taken from process arrival to its completion (including waiting time and execution time).

Average Turnaround Time:

SJN: P6: 3 ms (burst time) + 0 ms (waiting time) = 3 ms P4: 5 ms + 3 ms = 8 ms P3: 5 ms + 8 ms = 13 ms P1: 6 ms + 13 ms = 19 ms P2: 7 ms + 19 ms = 26 ms P5: 10 ms + 26 ms = 36 ms

Average Turnaround Time (SJN) = (3 + 8 + 13 + 19 + 26 + 36) / 6 = 21.83 ms

Priority Scheduling: P4: 5 ms (burst time) + 0 ms (waiting time) = 5 ms P6: 3 ms + 5 ms = 8 ms P1: 6 ms + 8 ms = 14 ms P3: 5 ms + 14 ms = 19 ms P2: 7 ms + 19 ms = 26 ms P5: 10 ms + 26 ms = 36 ms

Average Turnaround Time (Priority Scheduling) = (5 + 8 + 14 + 19 + 26 + 36) / 6 = 18 ms

Round Robin (RR): The order of execution and the number of time slices required by each process will determine the turnaround time. Since the number of time slices cannot be determined without considering the context switches and specific scheduling, we cannot provide an accurate average turnaround time for RR without additional information.

Based on the calculations for SJN and Priority Scheduling, the average turnaround time for Priority Scheduling is lower (18 ms) compared to SJN (21.83 ms). Therefore, Priority Scheduling appears to provide better performance in terms of turnaround time for the given set of processes.

---

For More Updates Join Our Channels :

---