Cpu Scheduling Practice Questions

CPU scheduling algorithms decide how the CPU is assigned to processes. The key difference between them is whether they are preemptive or non-preemptive. In preemptive scheduling, the OS can stop a running process and give the CPU to another (e.g., if a higher-priority process arrives or a time slice ends). In non-preemptive scheduling, once a process starts, it runs until it finishes its CPU burst or voluntarily gives up the CPU, and cannot be forced to stop.

Let's look at the given options:

• Shortest Remaining Time First (SRTF): This is preemptive. If a new process arrives with a shorter remaining CPU burst than the currently running one, the current process is interrupted.
• First Come First Serve (FCFS): This is non-preemptive. Processes run in the order they arrive. Once a process starts, it executes completely without interruption based on other processes arriving.
• Round Robin Scheduling: This is preemptive. Processes are given a fixed time slice (quantum). If a process doesn't finish within its quantum, it's preempted and moved to the ready queue.
• Priority Scheduling: This can be both preemptive and non-preemptive, depending on its implementation.

Based on these definitions, First Come First Serve (FCFS) inherently cannot be preemptive, as it executes processes strictly in their arrival order until completion or voluntary I/O blocking.

The processes arrive and are executed in the sequence: $A_1(10, 6)$, $C_1(11, 8)$, $A_2(20, 6)$, $C_2(22, 8)$, $A_3(30, 6)$, $C_3(33, 8)$, $A_4(40, 6)$, $C_4(44, 8)$, $A_5(50, 6)$, and $C_5(55, 8)$.
Using FCFS scheduling, the start times ($S_i$) are calculated cumulatively: $S_1=10$, $S_2=16$, $S_3=24$, $S_4=30$, $S_5=38$, $S_6=44$, $S_7=52$, $S_8=58$, $S_9=66$, $S_{10}=72$.
Waiting time for each process is $W_i = S_i - Arrival_i$: $W_1=0$, $W_2=5$, $W_3=4$, $W_4=8$, $W_5=8$, $W_6=11$, $W_7=12$, $W_8=14$, $W_9=16$, $W_{10}=17$.
The total waiting time is $\sum W_i = 0+5+4+8+8+11+12+14+16+17 = 95$.
The average waiting time is $\frac{95}{10} = 9.5$ seconds.

[CORRECT_OPTION: N/A]

1. Construct a Gantt chart for the Shortest Remaining Time First (SRTF) scheduling algorithm based on the given arrival and execution times of processes $P_1, P_2, P_3, P_4$.
2. Calculate the completion time (CT) for each process by tracing the Gantt chart. For $P_1$, CT = 16; for $P_2$, CT = 38; for $P_3$, CT = 8; for $P_4$, CT = 25.
3. Determine the turnaround time (TAT) for each process using the formula: TAT = CT - Arrival Time (AT).
   $TAT_{P1} = 16 - 0 = 16$
   $TAT_{P2} = 38 - 1 = 37$
   $TAT_{P3} = 8 - 2 = 6$
   $TAT_{P4} = 25 - 8 = 17$
4. Calculate the average turnaround time by summing the individual turnaround times and dividing by the number of processes:
   $\text{Average TAT} = \frac{16 + 37 + 6 + 17}{4} = \frac{76}{4} = 19$

The problem asks for the average waiting time of four processes ($P_1, P_2, P_3, P_4$) on two processors ($M_1, M_2$) using a non-preemptive priority scheduling. All processes arrive at time 0.

The CPU bursts are given as:
$P_1: 20 \text{ ms}$
$P_2: 16 \text{ ms}$
$P_3: 25 \text{ ms}$
$P_4: 10 \text{ ms}$

The priority rules are:
For $M_1$: $P_1 > P_3 > P_2 > P_4$ (Highest priority $P_1$, lowest $P_4$)
For $M_2$: $P_2 > P_3 > P_4 > P_1$ (Highest priority $P_2$, lowest $P_1$)

Since all processes arrive at time 0, and we have two processors, the two highest priority processes will be scheduled first on their respective processors.

Let's consider the priorities:
On $M_1$, $P_1$ has the highest priority.
On $M_2$, $P_2$ has the highest priority.

So, at time $t=0$:
$P_1$ starts on $M_1$.
$P_2$ starts on $M_2$.

Completion times:
$P_1$ completes at $0 + 20 = 20 \text{ ms}$. Processor $M_1$ becomes free.
$P_2$ completes at $0 + 16 = 16 \text{ ms}$. Processor $M_2$ becomes free.

Now, at $t=16 \text{ ms}$, $M_2$ is free. The remaining processes are $P_3$ and $P_4$.
Let's check their priorities for $M_2$: $P_2 > P_3 > P_4 > P_1$. Between $P_3$ and $P_4$, $P_3$ has higher priority on $M_2$.
So, at $t=16 \text{ ms}$, $P_3$ starts on $M_2$.
$P_3$ completes at $16 + 25 = 41 \text{ ms}$. Processor $M_2$ becomes free.

At $t=20 \text{ ms}$, $M_1$ is free. The only remaining process is $P_4$.
Let's check its priority for $M_1$: $P_1 > P_3 > P_2 > P_4$. $P_4$ is the lowest priority for $M_1$. However, it's the only one left.
So, at $t=20 \text{ ms}$, $P_4$ starts on $M_1$.
$P_4$ completes at $20 + 10 = 30 \text{ ms}$. Processor $M_1$ becomes free.

Now, let's calculate the waiting times:
Waiting time for $P_i = \text{Start Time of } P_i - \text{Arrival Time of } P_i$. Since all arrival times are 0:
$WT_{P_1} = 0 \text{ ms}$ (started at $t=0$ on $M_1$)
$WT_{P_2} = 0 \text{ ms}$ (started at $t=0$ on $M_2$)
$WT_{P_3} = 16 \text{ ms}$ (started at $t=16$ on $M_2$)
$WT_{P_4} = 20 \text{ ms}$ (started at $t=20$ on $M_1$)

Total waiting time = $0 + 0 + 16 + 20 = 36 \text{ ms}$.
Average waiting time = $\frac{\text{Total Waiting Time}}{\text{Number of Processes}} = \frac{36}{4} = 9 \text{ ms}$.

The average waiting time of the processes is 9 milliseconds.

The scheduling can be summarized as follows:
Processor $M_1$: $P_1$ (0-20 ms), $P_4$ (20-30 ms)
Processor $M_2$: $P_2$ (0-16 ms), $P_3$ (16-41 ms)

We have four processes with (Arrival Time, Burst Time):
A: (0, 10)
B: (2, 6)
C: (4, 3)
D: (6, 7)

1. Shortest Remaining Time First (SRTF - Preemptive):

• t=0: Process A arrives. A starts. Remaining A=10.
• t=2: Process B arrives. Current remaining A=8. B (6) < A (8). B preempts A. B starts. Remaining B=6, A=8.
• t=4: Process C arrives. Current remaining B=4. C (3) < B (4). C preempts B. C starts. Remaining C=3, B=4, A=8.
• t=6: Process D arrives. Current remaining C=1. D (7) > C (1). C continues. Remaining C=1, D=7, B=4, A=8.
• t=7: Process C completes. Remaining B=4, D=7, A=8. B (4) is shortest. B resumes. Remaining B=4, D=7, A=8.
• t=11: Process B completes. Remaining D=7, A=8. D (7) is shortest. D starts. Remaining D=7, A=8.
• t=18: Process D completes. Remaining A=8. A resumes. Remaining A=8.
• t=26: Process A completes.

Gantt Chart (SRTF):
| A | B | C | B | D | A |
|---|---|---|---|---|---|
0 2 4 6 7 11 18 26

Completion Times (CT):
C: 7
B: 11
D: 18
A: 26

Turnaround Time (TAT) = CT - AT:
C: 7 - 4 = 3
B: 11 - 2 = 9
D: 18 - 6 = 12
A: 26 - 0 = 26

Waiting Time (WT) = TAT - BT:
C: 3 - 3 = 0
B: 9 - 6 = 3
D: 12 - 7 = 5
A: 26 - 10 = 16

Average Waiting Time (SRTF) = (0 + 3 + 5 + 16) / 4 = 24 / 4 = 6.

2. Non-Preemptive Shortest Job First (NP-SJF):

• t=0: Process A arrives. A starts. Remaining A=10.
• t=2: Process B arrives. B (6) is shorter than A (10), but A is non-preemptive, so A continues.
• t=4: Process C arrives. C (3) is shorter. A continues.
• t=6: Process D arrives. D (7) is longer. A continues.
• t=10: Process A completes. Available processes: B(6), C(3), D(7). C (3) is shortest. C starts.
• t=13: Process C completes. Available processes: B(6), D(7). B (6) is shortest. B starts.
• t=19: Process B completes. Available processes: D(7). D starts.
• t=26: Process D completes.

Gantt Chart (NP-SJF):
| A | C | B | D |
|---|---|---|---|
0 10 13 19 26

Completion Times (CT):
A: 10
C: 13
B: 19
D: 26

Turnaround Time (TAT) = CT - AT:
A: 10 - 0 = 10
C: 13 - 4 = 9
B: 19 - 2 = 17
D: 26 - 6 = 20

Waiting Time (WT) = TAT - BT:
A: 10 - 10 = 0
C: 9 - 3 = 6
B: 17 - 6 = 11
D: 20 - 7 = 13

Average Waiting Time (NP-SJF) = (0 + 6 + 11 + 13) / 4 = 30 / 4 = 7.5.

Average waiting times: SRTF = 6, NP-SJF = 7.5.
This matches option (B).
===END_Q37===

Starvation occurs when a process is perpetually denied access to a resource or CPU, even though it is available.
First-in First-Out (FIFO) and Round Robin (RR) scheduling algorithms do not typically cause starvation because they ensure that every process eventually gets a turn.
Priority Scheduling can cause starvation if high-priority processes continuously arrive, preventing low-priority processes from ever executing.
Shortest Job First (SJF) can also cause starvation if short jobs continuously arrive, preventing long jobs from ever executing.
Therefore, Priority Scheduling and Shortest Job First can potentially cause starvation.

The problem describes a round robin scheduling with a time quantum of 4 units, processes P, Q, R, S arriving at $t=0$.
There are specific context switch counts:

• One context switch from S to Q.
• One context switch from R to Q.
• Two context switches from Q to R.
• No context switch from S to P.
• Switching to a ready process after termination is also a context switch.

Let's test each option by constructing a Gantt chart and checking context switches.
A context switch means switching from one process to another.
Consider the Gantt chart for the sequence of processes running.

Option (A): P = 4, Q = 10, R = 6, S = 2
Initial state: P, Q, R, S are ready at t=0. Let's assume P runs first.
P(4) Q(10) R(6) S(2)
0 P(4) 4
Context switch: P->Q (1)
4 Q(4) 8 (Q remaining: 6)
Context switch: Q->R (1)
8 R(4) 12 (R remaining: 2)
Context switch: R->S (1)
12 S(2) 14 (S terminates)
Context switch: S->P or S->Q (1) -- Let's say S->Q (Q is still ready).
14 Q(4) 18 (Q remaining: 2)
Context switch: Q->R (1)
18 R(2) 20 (R terminates)
Context switch: R->Q (1)
20 Q(2) 22 (Q terminates)
Total Context Switches: P->Q, Q->R, R->S, S->Q, Q->R, R->Q = 6 context switches.
S to Q: 1 (after S terminates, S->Q).
R to Q: 1 (after R terminates, R->Q).
Q to R: 2 (from 4-8 Q->R and 14-18 Q->R).
S to P: 0.
This option is possible.

Option (B): P = 2, Q = 9, R = 5, S = 1
0 P(2) 2 (P terminates)
Context switch: P->Q (1)
2 Q(4) 6 (Q remaining: 5)
Context switch: Q->R (1)
6 R(4) 10 (R remaining: 1)
Context switch: R->S (1)
10 S(1) 11 (S terminates)
Context switch: S->Q (1)
11 Q(4) 15 (Q remaining: 1)
Context switch: Q->R (1)
15 R(1) 16 (R terminates)
Context switch: R->Q (1)
16 Q(1) 17 (Q terminates)
Total Context Switches: 7.
S to Q: 1 (after S terminates, S->Q).
R to Q: 1 (after R terminates, R->Q).
Q to R: 2 (from 2-6 Q->R and 11-15 Q->R).
S to P: 0.
This option is possible.

Option (C): P = 4, Q = 12, R = 5, S = 4
0 P(4) 4
P->Q (1)
4 Q(4) 8 (Q rem: 8)
Q->R (1)
8 R(4) 12 (R rem: 1)
R->S (1)
12 S(4) 16
S->Q (1)
16 Q(4) 20 (Q rem: 4)
Q->R (1)
20 R(1) 21 (R terminates)
R->Q (1)
21 Q(4) 25 (Q terminates)
Total Context Switches: 7.
S to Q: 1 (after S terminates, S->Q).
R to Q: 1 (after R terminates, R->Q).
Q to R: 2 (from 4-8 Q->R and 16-20 Q->R).
S to P: 0.
This option is possible.

Option (D): P = 3, Q = 7, R = 7, S = 3
0 P(3) 3
P->Q (1)
3 Q(4) 7 (Q rem: 3)
Q->R (1)
7 R(4) 11 (R rem: 3)
R->S (1)
11 S(3) 14
S->Q (1)
14 Q(3) 17 (Q terminates)
Context switch S to Q. Count = 1.
Context switch Q to R (at 3->7). Count = 1.
Context switch R to Q (at 11->14, it should be R->Q).
14 Q(3) 17 (Q finishes)
17 R(3) 20 (R finishes)

Let's carefully trace the required context switches for option D:
P=3, Q=7, R=7, S=3. Quantum=4.
Order of processes in ready queue: P, Q, R, S.

1. Run P: 0-3 (P finishes). (CS from P to next, say Q)
   CS: P->Q (1)
2. Run Q: 3-7 (Q rem=3). (CS from Q to next, say R)
   CS: Q->R (1)
3. Run R: 7-11 (R rem=3). (CS from R to next, say S)
   CS: R->S (1)
4. Run S: 11-14 (S finishes). (CS from S to next, say Q as P is done)
   CS: S->Q (1)
5. Run Q: 14-17 (Q finishes). (CS from Q to next, say R)
   CS: Q->R (1)
6. Run R: 17-20 (R finishes).
   No process is left.

Total context switches: P->Q, Q->R, R->S, S->Q, Q->R. Total 5.
Let's check the conditions:

• One context switch from S to Q: YES (at 11-14 S finishes, S->Q at 14).
• One context switch from R to Q: NO. After R runs 7-11, it switches to S. After R finishes (17-20), there is no Q to switch to. So R->Q is 0.
• Two context switches from Q to R: YES (at 3-7 Q->R, and at 14-17 Q->R).
• No context switch from S to P: YES (S switches to Q, not P).

Since "One context switch from R to Q" is NOT met (it's zero in my trace), option (D) is not possible.
The solution image confirms this Gantt chart sequence (P, Q, R, S, Q, R) and identifies D as impossible.

Let's analyze each statement:
A. Turnaround time includes waiting time: Turnaround time is the total time from submission to completion, which includes execution time, waiting time in the ready queue, and I/O time. So, this statement is true.
B. The goal is to only maximize CPU utilization and minimize throughput: CPU scheduling aims to maximize CPU utilization AND throughput, and minimize turnaround time, waiting time, and response time. So, stating "only maximize CPU utilization and minimize throughput" is incorrect. This statement is false.
C. Round-robin policy can be used even when the CPU time required by each of the processes is not known a priori: Round-robin is a preemptive scheduling algorithm that assigns a fixed time quantum to each process. It does not require prior knowledge of burst times, making it suitable for interactive systems. So, this statement is true.
D. Implementing preemptive scheduling needs hardware support: Preemptive scheduling requires a timer interrupt mechanism to allow the operating system to regain control of the CPU from a running process after a certain time slice. This timer is a hardware component. So, this statement is true.
Therefore, statements A, C, and D are correct.

To achieve the minimum average waiting time in a non-preemptive scheduler when all processes arrive at time zero, the Shortest Job First (SJF) scheduling algorithm is used.
The CPU bursts are 16 ms, 20 ms, and 10 ms. Arranging them in increasing order gives 10 ms, 16 ms, 20 ms.
The waiting time for the first process (10 ms burst) is 0 ms.
The waiting time for the second process (16 ms burst) is 10 ms.
The waiting time for the third process (20 ms burst) is $10 + 16 = 26$ ms.
The average waiting time is $\frac{0 + 10 + 26}{3} = \frac{36}{3} = 12$ milliseconds.

The Round Robin scheduling algorithm is a preemptive CPU scheduling mechanism primarily used in time-sharing systems. It operates by assigning each process a fixed time interval known as a time quantum (or time slice), denoted as $T_q$. Once the execution time reaches $T_q$, the operating system interrupts the current process and switches to the next one in the ready queue to ensure fair resource distribution. Other options, such as shortest job, priority, and multilevel queue scheduling, prioritize processes based on burst time or priority levels rather than a fixed $T_q$. Thus, the definition of time quantum is intrinsic to the Round Robin algorithm.

To find the absolute difference between the average turnaround times (TAT) for SJF and RR, we first calculate the TAT for each scheduling algorithm.

For Shortest Job First (SJF):
The processes are scheduled in order of their burst times: $P_3 (2), P_4 (4), P_2 (7), P_1 (8)$.
Completion times: $P_3 = 2$, $P_4 = 2+4 = 6$, $P_2 = 6+7 = 13$, $P_1 = 13+8 = 21$.
Turnaround times (TAT = Completion Time - Arrival Time, with Arrival Time = 0):
$TAT_{P_3} = 2$, $TAT_{P_4} = 6$, $TAT_{P_2} = 13$, $TAT_{P_1} = 21$.
Average TAT for SJF = $(2 + 6 + 13 + 21) / 4 = 42 / 4 = 10.5$ ms.

For Round Robin (RR) with time quantum = 4 ms, and order $P_1, P_2, P_3, P_4$:
Gantt chart:
$P_1 (4), P_2 (4), P_3 (2), P_4 (4), P_1 (4), P_2 (3)$
Completion times: $P_3 = 4+4+2 = 10$, $P_4 = 10+4 = 14$, $P_1 = 14+4 = 18$, $P_2 = 18+3 = 21$.
Turnaround times:
$TAT_{P_1} = 18$, $TAT_{P_2} = 21$, $TAT_{P_3} = 10$, $TAT_{P_4} = 14$.
Average TAT for RR = $(18 + 21 + 10 + 14) / 4 = 63 / 4 = 15.75$ ms.

The absolute difference between the average TATs is $|10.5 - 15.75| = |-5.25| = 5.25$ ms.

[CORRECT_OPTION: 5.25]

To find the value of $t$ for 4 context switches (excluding the start and end), we analyze the scheduling of the tasks: $P_1$ (15 units, arrives at 0), $P_2$ (12 units, arrives at $t$), and $P_3$ (5 units, arrives at 8).

1. At time $t$, $P_2$ arrives and preempts $P_1$ if its remaining time is less than $P_1$'s remaining time: $12 < 15 - t \implies t < 3$. This is the first context switch.
2. At time 8, $P_3$ arrives with 5 units remaining. $P_2$ has $12 - (8 - t) = 4 + t$ units remaining. $P_3$ preempts $P_2$ if $5 < 4 + t \implies t > 1$. This is the second context switch.
3. Once $P_3$ finishes at $8 + 5 = 13$, $P_2$ resumes (third context switch), and after $P_2$ finishes, $P_1$ resumes (fourth context switch).
4. For these 4 context switches to occur, we require $1 < t < 3$. Given the provided options, $0 < t < 3$ is the range that contains this condition.

We are given that the average waiting time is 1 ms. We can trace the execution of the preemptive Shortest Remaining Time First (SRTF) algorithm and find the value of Z that satisfies this condition.

• At t=1, P2 (burst 1) preempts P1 (remaining 2). P2 finishes at t=2 (WT=0).
• P1 resumes and finishes at t=4 (WT=1).
• At t=4, P3 (burst 3) and P4 (burst Z) are ready. P4 must be chosen to run next, implying Z < 3.
• Let's test Z=2. P4 runs from t=4 to t=6 and finishes (WT=0).
• P3 runs from t=6 to t=9 and finishes (WT=3).
  The waiting times are P1:1, P2:0, P3:3, P4:0. The average is $(1+0+3+0)/4 = 1$ ms. This matches the given information, so Z must be 2.

The Shortest Remaining Time First (SRTF) algorithm is a pre-emptive scheduling method. The execution proceeds as follows, tracked by a Gantt chart:

1. At t=0, P1 starts.
2. At t=3, P2 arrives with a burst time of 3, which is less than P1's remaining time of 4. P2 preempts P1 and runs to completion at t=6.
3. At t=6, P4 arrives with a burst time of 2, which is the shortest. P4 runs to completion at t=8.
4. At t=8, P1 (remaining time 4) resumes and finishes at t=12.
5. At t=12, P3 (burst time 5) runs and finishes at t=17.

Waiting times are: P1=5, P2=0, P3=7, P4=0.
The average waiting time is $\frac{5+0+7+0}{4} = \frac{12}{4} = 3$ ms.

This problem requires applying the preemptive priority scheduling algorithm. The execution is traced using a Gantt chart.

1. At t=0, P1 starts.
2. At t=2, P4 arrives with higher priority (1 < 2) and preempts P1.
3. At t=5, P2 arrives with the highest priority (0 < 1) and preempts P4. P2 runs to completion at t=33.
4. Next, the remaining part of P4 runs until t=40.
5. Then, the remaining part of P1 runs until t=49.
6. P3 runs from t=49 to t=51.
7. Finally, P5 runs from t=51 to t=67.

Waiting times are: P1=38, P2=0, P3=37, P4=28, P5=42.
The average waiting time is $\frac{38+0+37+28+42}{5} = \frac{145}{5} = 29$.

Belady's anomaly describes the phenomenon where increasing the number of available page frames can lead to an increase in the number of page faults.

1. Belady's Anomaly Definition: This anomaly occurs when a page replacement algorithm produces more page faults for a reference string when allocated more memory frames.
2. FIFO (First-In, First-Out): This policy evicts the page that has been in memory for the longest time, regardless of how often it's being used.
3. FIFO and Anomaly: FIFO's decision to replace pages is based solely on their arrival time, not on their usage frequency or future access. This "memory-less" property can cause it to evict frequently used pages, leading to an increase in page faults with more frames.
4. Other Policies: Optimal and LRU (Least Recently Used) are stack algorithms, meaning they possess the inclusion property (the set of pages in memory with $m$ frames is always a subset of pages in memory with $m+1$ frames). Stack algorithms, including LRU and Optimal, provably do not suffer from Belady's anomaly. MRU (Most Recently Used) is not a stack algorithm but often behaves similarly to FIFO in exhibiting the anomaly.

Therefore, FIFO is the classic example where Belady's anomaly can occur.

The goal is to minimize the average waiting time. For a set of processes that arrive at the same time, the Shortest Job First (SJF) scheduling algorithm is provably optimal in minimizing average waiting time. Since the processes are non-preemptive (CPU-bound) and arrive simultaneously, the Shortest Remaining Time First (SRTF) algorithm behaves identically to SJF. It will execute the process with the shortest CPU burst first, then the next shortest, and so on, which minimizes the overall waiting time for the set.

A Real-Time Operating System ($RTOS$) requires deterministic behavior to guarantee that critical tasks complete within strict time constraints. Pre-emptive scheduling is the most suitable approach because it allows the system to immediately interrupt a currently running lower-priority task when a higher-priority, time-sensitive task arrives. This mechanism ensures that $RTOS$ tasks meet their deadlines, whereas First-Come-First-Serve ($FCFS$) and Round Robin scheduling lack the necessary priority-based responsiveness. Consequently, pre-emptive scheduling provides the predictability required for real-time applications, while Random scheduling remains entirely unsuitable due to its non-deterministic nature.

The problem is solved using the Preemptive Shortest Remaining Time First (SRTF) scheduling algorithm. The execution is as follows:

1. P1 runs from t=0 to t=3. (P1 remaining: 7)
2. P2 arrives and preempts P1. P2 runs from t=3 to t=7. (P2 remaining: 2)
3. P3 arrives and preempts P2. P3 runs from t=7 to t=8. (P3 finishes)
4. P2 resumes and runs from t=8 to t=10. (P2 finishes)
5. P4 runs from t=10 to t=13. (P4 finishes)
6. P1 runs from t=13 to t=20. (P1 finishes)

Turnaround Times (TAT = Completion Time - Arrival Time):
P1: 20-0=20, P2: 10-3=7, P3: 8-7=1, P4: 13-8=5.
Average TAT = (20+7+1+5)/4 = 33/4 = 8.25 ms.

Given that each job requires $10 \text{ minutes}$ of CPU time and incurs $50\%$ I/O wait time, we must determine the total time per job. Let $T_{total}$ represent the total duration of a single job. If $50\%$ of this time is I/O wait, then the remaining $50\%$ is CPU time. Thus:

$0.5 \times T_{total} = 10 \text{ minutes}$
$T_{total} = \frac{10}{0.5} = 20 \text{ minutes per job}$

Since the two jobs run sequentially, the total time required is the sum of the time for both jobs:
$20 \text{ minutes} + 20 \text{ minutes} = 40 \text{ minutes}$