CS Free MCQ Bank

[ Option B ]

For statement (P), where processes are divided into categories like foreground and background, the correct match is Multilevel Queue Scheduling. This algorithm classifies processes into separate queues such as interactive and batch, each with its own scheduling policy, making it suitable for such categorization.
For statement (Q), processes announce their deadlines and are not periodic, which corresponds to Earliest Deadline First Scheduling. This is a dynamic real-time scheduling technique where priorities are assigned based on the nearest deadline, and it works effectively for aperiodic tasks.
In (R), processes have a producer–consumer relationship, indicating interdependent or communicating processes. This matches Gang Scheduling, where related processes are scheduled simultaneously on multiple processors to ensure proper synchronization and efficient execution.
Finally, (S) describes processes that announce deadlines and are periodic, which fits Rate Monotonic Scheduling. This is a fixed-priority scheduling algorithm designed specifically for periodic tasks, where priority is assigned based on the rate.

[ Option D ]

In Round Robin Scheduling, each process is given a fixed time slice (time quantum) in a cyclic order. If a process does not finish within its time slice, it goes to the end of the Ready Queue.
Here, all processes arrive at time 0 and the time quantum = 2.

Since P4 has burst time equal to time quantum, it completes in its first execution cycle, before others finish.

[ Option B ]

Different types of operating systems are designed for different purposes such as improving CPU utilization, providing quick response, or meeting time limits.

[ Option A ]

CPU Scheduling is the foundation of a Multiprogramming Operating System. In multiprogramming, several processes are kept in memory at the same time, and CPU scheduling decides which process will be given the CPU when it becomes available. This ensures efficient CPU utilization by keeping the processor busy as much as possible. CPU scheduling ensures that the CPU is never idle when there are processes ready to execute, improving throughput.

[ Option B ]

In priority-based scheduling, processes with lower priority may never get CPU time if higher priority processes keep arriving. This problem is called Starvation.
To solve this, the concept of Aging is used. In aging, the priority of a waiting process is gradually increased over time, so eventually it gets a chance to execute.

[ Option D ]

In an Operating System, the CPU scheduling process involves three levels of schedulers:

1. Long-Term Scheduler, decides which processes are admitted to the ready queue (controls degree of multiprogramming).
2. Short-Term Scheduler, selects which ready process gets CPU next.
3. Medium-Term Scheduler, temporarily suspends or swaps out processes from main memory to secondary storage (and brings them back later) to manage memory efficiently.

• It comes into action when the system needs to reduce the degree of multiprogramming.
• It does this by swapping out processes (moving them from main memory to disk) and swapping them back later when memory becomes available.

[ Option D ]

In priority-based scheduling, normally a higher priority task should execute before a lower priority task. However, a problem occurs when:

• A low-priority task holds a shared resource.
• A high-priority task needs that resource.
• The high-priority task must wait until the low-priority task releases it.

This situation is called Priority Inversion, because the expected priority order gets inverted, the higher priority task is forced to wait for the lower priority task.

• Priority Ceiling, is technique to prevent priority inversion.

[ Option B ]

The key point in the question is, the duration (burst time) of all tasks is known. Remember, when burst times are known in advance, the Shortest Job First (SJF) scheduling algorithm is considered the best because it minimizes the average waiting time.
Shortest Job First selects the process with the smallest execution time first. This ensures that short tasks do not wait behind long tasks, reducing overall waiting time.

[ Option D ]

In CPU scheduling, pre-emptive algorithms are those where a running process can be interrupted and the CPU is given to another process.
Round Robin Scheduling is always pre-emptive because each process is given a fixed Time Slice or Time Quantum. After this time expires, the process is interrupted, and the CPU is assigned to the next process in the queue.

[ Option C ]

The Convoy Effect is a performance problem that occurs in CPU scheduling, especially in algorithms like First-Come, First-Served (FCFS). In this situation, a long CPU-Bound process gets the CPU first. Meanwhile, several I/O-Bound processes have to wait in the Ready Queue.

Since the CPU is busy executing the long process, the shorter I/O-bound processes are delayed. As a result, the CPU stays idle when those I/O-bound processes later perform I/O operations, and overall system utilization drops.

[ Option C ]

In operating systems, processes are scheduled based on priority. Priority Inversion is a situation where a high-priority process is forced to wait because a low-priority process is holding a resource that it needs. This leads to an unexpected inversion of priorities.

[ Option D ]

In operating systems, CPU scheduling determines the order in which processes are executed. When processes are assigned to the CPU in the exact order they arrive or request it, this scheduling technique is called First-In-First-Served (FIFS), also commonly known as First-Come-First-Served (FCFS).
For example, if processes arrive in order P1 → P2 → P3, then execution will also happen in the same order: P1 → P2 → P3.

[ Option D ]

SRTF (Shortest Remaining Time First) is a Preemptive Scheduling algorithm where the process with the shortest remaining execution time is given the CPU. A long-running process might never get to execute if there is a continuous stream of new, short-burst processes arriving in the ready queue. The long-running process would always have a longer remaining time and would be repeatedly preempted, leading to starvation.

Preemptive scheduling may cause starvation, this is a general statement that is true. Starvation is a common problem in any Preemptive Scheduling algorithm that uses a priority or time-based approach, like SRTF or a Priority-Based Scheduler where low-priority processes might never get to run if there is a constant flow of high-priority processes.

Round Robin (RR) scheduling allocates CPU time in small time slices (quantum) to each process fairly, leading to better responsiveness compared to FCFS (First-Come, First-Serve), where a process waits (even short-burst ones) until the previous one completes because its Non-Preemptive Scheduling algorithm.

[ Option C ]

In FCFS (First Come First Serve) scheduling, processes are executed in the order of their arrival time.

Step 1: Order of Execution :

So, execution order: P2 → P3 → P1

Step 2: Gantt Chart :

Step 3: Turnaround Time (TAT) :
TAT = Completion Time-Arrival Time

Average TAT: (3+3+24)/3 = 30/3 = 10 ms

Step 4: Waiting Time (WT) :
WT = TAT-Execution Time

Average WT: (0+0+0)/3 = 0 ms
Thus:

• Average Turnaround Time = 10 ms
• Average Waiting Time = 0 ms
   

[ Option A ]

In Non-Preemptive SJF, once a process starts execution, it runs till completion, and at each decision point we choose the shortest burst time among the arrived processes.
At time 0: only P1 is available → executes from 0 to 7.
At time 1: P1 already running. At 7 P2, P3, P4 have arrived. Among P2(4), P3(9), P4(5), P2 has shortest burst (4). So, P2 from 7 to 11.
From 11 onward, remaining: P3(9), P4(5). P4 is shorter. So, P4 from 11 to 16.
Finally, P3 from 16 to 25.

• TAT=Completion Time (CT)-Arrival Time (AT).
• Sum of Waiting Time = 0+6+14+8 = 28
• Average Waiting Time = 28/4 = 7

[ Option D ]

In Shortest Job First (SJF) scheduling, processes are executed in ascending order of burst time.
Arrange Processes (Ascending Burst Time):

Therefore, execution order are P4 → P1 → P3 → P2.
Calculate Waiting Time of P2:
The waiting time of process P2 is calculated by adding the burst times of all processes executed before it, since P4, P1, and P3 execute before P2 with burst times 3, 6, and 7 respectively, the total waiting time of P2 is 3+6+7 = 16.

Note:

• SJF minimizes average waiting time.
• Long processes (like P2) may suffer from starvation.

[ Option D ]

In an operating system, CPU scheduling determines the order in which processes are executed. To evaluate scheduling algorithms, we use certain key performance metrics,  Throughput, Turnaround Time, Waiting Time, and Response Time.

[ Option A ]

SPN (Shortest Process Next), also known as Shortest Job First (SJF) (non-preemptive), is a CPU scheduling algorithm that selects the ready process with the shortest service (burst) time for execution next. The goal is to minimize the average waiting and turnaround times.
Turnaround Time (TAT) = Completion Time − Arrival Time.
 

Total Turnaround Time = 3 + 7 + 3 + 11 + 14 = 38
Average Turnaround Time = 38 / 5 = 7.6

[ Option C ]

In process scheduling, the time intervals are defined as:

From the given diagram,

• Time1 represents the duration from arrival to the start of execution, which is the Waiting Time (W) because the process waits before getting CPU. 
• Time2 represents the duration during which the process is actually executing, so it corresponds to the Run Time (R). 
• Time3 represents the time from arrival to the first output, which is the Response Time (S), indicating how quickly the system responds.
• Time4 represents the total time from arrival to completion, which is the Turnaround Time (T), including both waiting and execution time.

[ Option C ]

In an Operating System (OS), the ready state contains all processes that are prepared to execute and are waiting for CPU allocation. The ready queue can hold many processes at the same time.
The number of processes in the ready state does not depend on the number of CPUs.