CS Free MCQ Bank

[ 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 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 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 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 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.