Test: CPU & I/O Scheduling- 2 - Computer Science Engineering (CSE) MCQ

Turnaround time is the total time taken between the submission of a program/process/thread/task (Linux) for execution and the return of the complete output to the customer/user. Turnaround Time = Completion Time - Arrival Time. FCFS = First Come First Serve (A, B, C, D) SJF = Non-preemptive Shortest Job First (A, B, D, C) SRT = Shortest Remaining Time (A(3), B(1), C(4), D(2), B(5)) RR = Round Robin with Quantum value 2 (A(2), B(2), A(1),C(2),B(2),D(2),C(2),B(2)  

1. Both SJF and Shortest Remaining time first algorithms may cause starvation. Consider a situation when long process is there in ready queue and shorter processes keep coming.
2. SJF is optimal in terms of average waiting time for a given set of processes, but problems with SJF is how to know/predict time of next job.

Turnaround time is the total time taken by the process between starting and the completion and waiting time is the time for which process is ready to run but not executed by CPU scheduler. As we know, in all CPU Scheduling algorithms, shortest job first is optimal i.ie. it gives minimum turn round time, minimum average waiting time and high throughput and the most important thing is that shortest remaining time first is the pre-emptive version of shortest job first. shortest remaining time first scheduling algorithm may lead to starvation because If the short processes are added to the cpu scheduler continuously then the currently running process will never be able to execute as they will get pre-empted but here all the processes are arrived at same time so there will be no issue such as starvation. So, the answer is Shortest remaining time first, which is answer (A).

PreEmptive Shortest Remaining time first scheduling, i.e. that processes will be scheduled on the CPU which will be having least remaining burst time( required time at the CPU). The processes are scheduled and executed as given in the below Gantt chart.

Turn Around Time(TAT) = Completion Time(CT) - Arrival Time(AT) TAT for P1 = 20 - 0 = 20 TAT for P2 = 10 - 3 = 7 TAT for P3 = 8- 7 = 1 TAT for P4 = 13 - 8 = 5 Hence, Average TAT = Total TAT of all the processes / no of processes = ( 20 + 7 + 1 + 5 ) / 4 = 33 / 4 = 8.25   Thus, A is the correct choice.

10 processes -> 1 min
1 process-> 1/10 min = 6 sec (Arrival rate)
Each process -> 3 sec service time 3/6 * 100 = 50% of time CPU is busy.

Scheduler decides that the interrupted process will complete execution or some other process will be executed. If the interrupt signaled an I/O completion event, and at the same time a high priority process came into Ready state then the scheduler block the interrupted process and dispatch the high priority process in the running state. If low priority process comes into Ready state then scheduler dispatch the interrupted process. Hence, D is correct.

If we take value of x is 2, then we have gantt chart as

So, completion time of P1, P2, P3, and P4 are 6, 2, 11, and 8 respectively. Turn around time of P1, P2, P3, and P4 are 6, 1, 8, and 4 respectively. Waiting time of P1, P2, P3, and P4 are 1, 0, 5, and 2 resectively. Therefore, average waiting time = (1+0+5+2) / 4 = 8/2 = 2 Option (B) is correct.

First we will make gantt chart of given process then we will calculate turn around time and waiting time of individual process.

Now we have to calculate average waiting time for schedule:avg waiting time = wt(P1 + P2 + P3 + P4 )/number of process.    ie.            

(9 + 0 + 15 + 2) / 4
= 26 / 4
= 6.5

There are three type of scheduler:

1. Short-term scheduler
2. Mid-term scheduler
3. Long-term scheduler

Dispatcher is responsible for handovering the control of CPU to the newly selected process by the Short-term scheduler. Refer: Process Scheduler So, option (A) is correct.

1. In First Come First Serve(FCFS) if a process with a very large Burst Time comes before other processes, the other process will have to wait for a long time but it is clear that other process will definitely get their chance to execute, so it will not suffer from starvation.
2. In Round Robin there is a fixed time quant and every process will get their chance to be executed, so no starvation is here.
3. In Priority based scheduling if higher priority process keep on coming then low priority process will suffer from starvation.
4. In Shortest Job First(SJF) if process with short process time keep on coming continuously then process with higher burst time will do wait and suffer from starvation.
5. In Shortest remaining time first(SRTF) process with shortest burst time will execute first because of this process with high burst time may suffer from starvation.

So, option (C) is correct.

Jitter is the variation / displacement between the signals or data being sent. Hard real operating systems deal with more sensitive systems which require strict time deadlines like engine control systems, satellite launching systems etc while soft real operating systems do not require strict timing constraints and a bit delay is permissible, like mobile phones, online database systems. So hard real operating systems require minimised jitter.

There are 3 context switch. So. option (A) is correct.

We will solve it by minimizing the avg Waiting Time and Take x = 4 BT = Burst or Execution time CT = completion time P = Process AWT = Average Waiting Time AT = Arrival time WT = Waiting time

We get minimum average waiting time from the sequence given in option (B)

Minimum CPU utilization is not an optimization criterion as various optimization techniques and scheduling algorithms are used to bring the best CPU performance.

It can be seen that along with the sequential execution of T1 and T2, (T3, T6), (T4, T7) and (T5, T8), all these three processes can be executed in parallel. So total number of processes that can be executed in 4 units time using 5 available processors = 5*4 = 20 But here processes that are executing in 4 units time = 8 Throughput = 8/20 * 100 = 40% So, option (B) is correct.

A scheduling Algorithm assigns priority proportional to the waiting time of a process. Every process starts with priority zero (lowest priority). The scheduler reevaluates the process priority for every ‘T’ time units and decides next process to be scheduled. If the process have no I/O operations and all arrive at time zero, then the scheduler implements Round Robin Scheduling criteria. So, option (B) is correct.

Number of processes per minute = 6 Burst time of each process = 7 secs
CPU utilization time within a minute = 6*7 = 42 secs
% CPU utilization = useful time / total time * 100
= (42/60) * 100 
 70%
Option (A) is correct.

The two-level CPU scheduling is used when memory is too small to hold all the ready processes because it facilitates putting some set of processes into memory and a choice is made from that. So, option (D) is correct.

For Multi Level Feedback Queue processor scheduling algorithm:

• Queues have different priorities
• Each queue may have different scheduling algorithm
• Processes are not permanently assigned to a queue.
• This algorithm can be configured to match a specific system under design

In Non - preemptive algorithms context switching will never take place because it doesn't allow to switch the process until it is completed fully. So, option (C) is correct.