General Step-by-Step Approach to Solve Scheduling Algorithm Problems

1. Understanding the Problem Statement

1.​ Identify the given inputs:
○​ Processes (P1, P2, P3, ...).
○​ Arrival Time (AT): When the process arrives in the ready queue.
○​ Burst Time (BT) or Service Time: Time required by the process for execution.
○​ Scheduling Policy: FCFS, SJF, Round Robin, Priority, etc.
○​ Time Quantum (for Round Robin).
2.​ Required outputs:​

○​ Completion Time (CT): When a process finishes execution.

○​ Turnaround Time (TAT): TAT=CT−ATTAT = CT - AT.
○​ Waiting Time (WT): WT=TAT−BTWT = TAT - BT.
○​ Average Waiting Time (AWT): Sum of all waiting times divided by number of processes.
○​ Average Turnaround Time (ATT): Sum of all turnaround times divided by number of processes.
○​ Gantt Chart: Visual representation of process execution over time.

2. First Come, First Served (FCFS) - Non-Preemptive Scheduling

Step-by-Step Approach:

1.​ Sort processes by Arrival Time (AT).

2.​ Assign the start time of each process based on completion of the previous one.
○​ If the CPU is idle, move time forward to the next arrival.
3.​ Calculate Completion Time (CT): CT=StartTime+BurstTimeCT = Start Time + Burst Time
4.​ Calculate Turnaround Time (TAT): TAT=CompletionTime−ArrivalTimeTAT = Completion Time - Arrival
Time
5.​ Calculate Waiting Time (WT): WT=TurnaroundTime−BurstTimeWT = Turnaround Time - Burst Time
6.​ Compute AWT and ATT.
7.​ Draw the Gantt Chart to visualize execution order.

Example Calculation:

Proces Arrival Time Burst Time Completion Turnaround Time Waiting

s Time Time

P1 0 3 3 3-0 = 3 3-3 = 0

P2 2 3 6 6-2 = 4 4-3 = 1

P3 3 2 8 8-3 = 5 5-2 = 3

P4 5 5 13 13-5 = 8 8-5 = 3

P5 9 3 16 16-9 = 7 7-3 = 4
3. Shortest Job First (SJF) - Non-Preemptive Scheduling
Step-by-Step Approach:

1.​ Sort the processes based on Arrival Time.

2.​ From available processes at any time, select the one with the shortest burst time.
3.​ Calculate Completion Time (CT): CT=StartTime+BurstTimeCT = Start Time + Burst Time
4.​ Calculate Turnaround Time (TAT): TAT=CT−ATTAT = CT - AT
5.​ Calculate Waiting Time (WT): WT=TAT−BTWT = TAT - BT
6.​ Compute AWT and ATT.
7.​ Draw the Gantt Chart to visualize execution order.

Key Considerations:

●​ If two processes have the same burst time, select the process that arrived first.
●​ SJF can minimize waiting time but may lead to starvation.

Example Order (after sorting by burst time):​

P3→P2→P5→P1→P4P3 \rightarrow P2 \rightarrow P5 \rightarrow P1 \rightarrow P4

4. Round Robin (RR) - Preemptive Scheduling

Step-by-Step Approach:

1.​ Determine the time quantum (Q).

2.​ Execute each process for a maximum of Q time units, then move to the next process.
3.​ Keep track of remaining burst times after each cycle.
4.​ If a process finishes within the quantum, record the completion time.
5.​ Continue cycling through the queue until all processes finish execution.
6.​ Calculate CT, TAT, WT, AWT, and ATT.
7.​ Draw the Gantt Chart based on executed time slices.

Example Calculation (Quantum = 2):​

Process execution order:​
P1(2)→P2(2)→P3(2)→P4(2)→P5(2)→P1(1)→P2(1)→P4(2)→P4(1)P1(2) \rightarrow P2(2) \rightarrow P3(2)
\rightarrow P4(2) \rightarrow P5(2) \rightarrow P1(1) \rightarrow P2(1) \rightarrow P4(2) \rightarrow P4(1)

5. Priority Scheduling - Non-Preemptive

Step-by-Step Approach:

1.​ Assign priorities to processes (lower number = higher priority).

2.​ Sort processes based on priority and arrival time.
3.​ Process with the highest priority is executed first.
4.​ Calculate Completion Time (CT).
5.​ Calculate Turnaround Time (TAT).
6.​ Calculate Waiting Time (WT).
 7.​ Compute AWT and ATT.
8.​ Draw the Gantt Chart for visualization.

Example Order (after priority assignment):​

P3→P2→P5→P4→P1P3 \rightarrow P2 \rightarrow P5 \rightarrow P4 \rightarrow P1

6. General Tips for Solving Scheduling Problems:

1.​ Sort carefully: Whether based on arrival time or other parameters, sorting is crucial.
2.​ Be accurate with calculations: Minor mistakes can lead to incorrect final results.
3.​ Use tables for better clarity: Keeping columns for all calculations helps avoid confusion.
4.​ Draw the Gantt chart for better visualization.
5.​ Practice different time quantum values in Round Robin for better understanding.
6.​ Understand advantages and limitations of each algorithm:
○​ FCFS: Simple but causes long waiting times (convoy effect).
○​ SJF: Minimizes waiting time but may cause starvation.
○​ Round Robin: Ensures fairness but may increase overhead.
○​ Priority Scheduling: Efficient but prone to starvation.

7. Summary Table of Scheduling Algorithms:

Algorithm Preemptive Scheduling Best For Drawbacks
Basis

FCFS No Arrival Time Batch Systems Convoy Effect

SJF No Burst Time Shorter Jobs First Starvation

Possible

Round Yes Time Quantum Time-sharing Increased

Robin Systems Overhead

Priority No Priority Critical Task Starvation

Handling Possible
Step-by-Step Approach to Solve Critical Section Problem with Resource
Allocation (Banker's Algorithm)
When solving problems related to resource allocation in operating systems, particularly using Banker's Algorithm,
the goal is to determine if the system is in a safe state and to find a safe sequence, if possible.

Given Problem Data:

1.​ Processes (P1, P2, P3, ...)
2.​ Resources (A, B, C, ...)
3.​ Given Tables:
○​ Allocation Matrix: Resources currently allocated to each process.
○​ Maximum Matrix: Maximum resources a process may need.
○​ Available Resources: Resources available for allocation.

Step-by-Step Solution Approach:

Step 1: Understand the given data

From the problem statement, extract the following:

●​ Number of processes (n)

●​ Number of resource types (m)
●​ Allocation Matrix: Shows currently allocated resources to each process.
●​ Maximum Matrix: Shows the maximum demand of each process.
●​ Available Vector: Shows the number of available resources.

Step 2: Calculate the Need Matrix

The Need Matrix represents the remaining resources a process needs to complete execution.

Need=Maximum−Allocation\text{Need} = \text{Maximum} - \text{Allocation}

For each process and each resource type, subtract the allocation matrix from the maximum matrix.

Example Calculation:

Proces Allocation (A, B, Maximum (A, B, Need (A, B, C)

s C) C)

P1 (0, 1, 0) (7, 5, 3) (7-0, 5-1, 3-0) = (7, 4,

3)

P2 (2, 0, 0) (3, 2, 2) (3-2, 2-0, 2-0) = (1, 2,

2)

P3 (3, 0, 2) (9, 0, 2) (9-3, 0-0, 2-2) = (6, 0,

0)
Step 3: Apply Banker's Algorithm to Find a Safe Sequence
1.​ Initialize Work and Finish arrays:​

○​ Work = Available resources (initially provided)

○​ Finish = [False, False, False, ...] for all processes (indicating if a process has finished)
2.​ Find a process that can be completed:​

○​ Compare each row of the Need matrix with the Work vector.
○​ If the Need of a process is ≤ Available, allocate the resources and mark the process as finished.
3.​ Update Work:​
Work=Work+Allocation of the completed process\text{Work} = \text{Work} + \text{Allocation} \text{ of the
completed process}
4.​ Repeat Steps 2-3 until all processes are marked as finished (safe state) or no more processes can satisfy the
condition (unsafe state).​

Step 4: Safe or Unsafe State Determination

●​ If all processes are marked Finished = True, the system is in a safe state, and the order in which processes
finished gives the safe sequence.
●​ If not all processes can finish, the system is in an unsafe state, meaning deadlock is possible.

Step 5: Example Execution

Suppose we have:

Available Resources: (A = 3, B = 3, C = 2)

Proces Allocation (A, B, Maximum (A, B, Need (A, B,

s C) C) C)

P1 (0, 1, 0) (7, 5, 3) (7, 4, 3)

P2 (2, 0, 0) (3, 2, 2) (1, 2, 2)

P3 (3, 0, 2) (9, 0, 2) (6, 0, 0)

Execution Order Steps:

1.​ P2 can finish since Need (1,2,2) ≤ Available (3,3,2).​

○​ Update Available: (3+2, 3+0, 2+0) = (5, 3, 2).

○​ Mark P2 as finished.
2.​ P1 can now finish since Need (7,4,3) cannot be satisfied, skip.​

3.​ P3 can finish since Need (6,0,0) ≤ Available (5,3,2).​

 ○​ Update Available: (5+3, 3+0, 2+2) = (8, 3, 4).
○​ Mark P3 as finished.
4.​ P1 can now finish since Need (7,4,3) ≤ Available (8,3,4).​

○​ Update Available: (8+0, 3+1, 4+0) = (8, 4, 4).

○​ Mark P1 as finished.

Safe Sequence: P2 → P3 → P1​

Since all processes can finish, the system is in a safe state.

Step 6: Final Calculation and Interpretation

●​ If a safe sequence is found, print the sequence and conclude the system is in a safe state.
●​ If no safe sequence exists, declare the system is in an unsafe state and potentially prone to deadlock.

Key Points to Remember:

1.​ Always calculate the Need matrix first.
2.​ Keep track of available resources at each step.
3.​ If at any point no process can proceed, the system is unsafe.
4.​ Banker's Algorithm ensures deadlock avoidance, not prevention.
General Step-by-Step Approach to Solving Page Replacement Problems
Page replacement algorithms are used in operating systems to manage memory efficiently by replacing pages in a
fixed-size frame when a new page needs to be loaded into memory. The goal is to minimize the number of page
faults, which occur when the required page is not in memory.

Step 1: Understand the Given Inputs

When solving a page replacement problem, you are typically given:

1.​ Page Reference String: A sequence of memory pages requested by processes.​

○​ Example: 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2
2.​ Number of Page Frames: The number of slots available in memory.​

○​ Example: 3 frames
3.​ Replacement Policy: The page replacement algorithm to be applied (e.g., FIFO, LRU, Optimal).​

Step 2: Key Performance Metrics to Calculate

Once you've applied the algorithm, you will compute:

1.​ Page Faults: When a requested page is not found in memory and must be loaded.
2.​ Page Hits: When a requested page is already in memory, avoiding a fault.
3.​ Hit Ratio: Hit Ratio=Number of Page HitsTotal Page Requests\text{Hit Ratio} = \frac{\text{Number of Page
Hits}}{\text{Total Page Requests}}
4.​ Miss Ratio: Miss Ratio=Number of Page FaultsTotal Page Requests\text{Miss Ratio} = \frac{\text{Number
of Page Faults}}{\text{Total Page Requests}}

Step 3: Approach to Different Page Replacement Policies

1. First-In-First-Out (FIFO) Algorithm

Concept:

●​ The page that entered first will be removed first when a new page needs to be loaded.
●​ Managed using a queue (FIFO structure).

Steps to Solve:

1.​ Start loading pages into frames based on their arrival sequence.
2.​ When the frames are full and a new page arrives, remove the oldest page.
3.​ Track page faults by checking if a page is in memory before loading.

Example Execution with 3 Frames:​

Page Reference String: 7, 0, 1, 2, 0, 3, 0, 4
 Ste Page Frame Page Fault
p Request s

1 7 [7] Yes

2 0 [7, 0] Yes

3 1 [7, 0, Yes
1]

4 2 [0, 1, Yes (7
2] replaced)

5 0 [1, 2, Yes (0
0] reloaded)

6 3 [2, 0, Yes
3]

7 0 [2, 0, No
3]

8 4 [0, 3, Yes
4]

Pros:

●​ Simple and easy to implement.​

Cons:
●​ Can lead to high page faults (Belady's Anomaly).

2. Least Recently Used (LRU) Algorithm

Concept:

●​ The page that has been least recently used is replaced when new pages arrive.
●​ Managed using a stack or a tracking mechanism.

Steps to Solve:

1.​ Load pages into memory in sequence.

2.​ When a new page arrives, remove the page that was accessed the longest time ago.
3.​ Track page access times to decide which to replace.

Example Execution with 3 Frames:​

Page Reference String: 7, 0, 1, 2, 0, 3, 0, 4

Ste Page Frame Page Fault

p Request s
1 7 [7] Yes

2 0 [7, 0] Yes

3 1 [7, 0, Yes
1]

4 2 [0, 1, Yes (7 removed)

2]

5 0 [1, 2, No (0 recently
0] used)

6 3 [2, 0, Yes
3]

7 0 [2, 0, No
3]

8 4 [0, 3, Yes
4]

Pros:

●​ Reduces page faults compared to FIFO.​

Cons:
●​ Requires tracking of recent usage, which can increase overhead.

3. Optimal Page Replacement Algorithm

Concept:

●​ The page that will be used the farthest in the future is replaced.
●​ Requires future knowledge of page requests (ideal scenario).

Steps to Solve:

1.​ Load pages into memory in sequence.

2.​ When a new page arrives and memory is full, look ahead in the reference string.
3.​ Replace the page that will not be used for the longest time in the future.

Example Execution with 3 Frames:​

Page Reference String: 7, 0, 1, 2, 0, 3, 0, 4

Ste Page Frame Page Replacement

p Request s Fault Decision

1 7 [7] Yes -

2 0 [7, 0] Yes -
 3 1 [7, 0, Yes -
1]

4 2 [0, 1, Yes 7 (not needed soon)

2]

5 0 [1, 2, No -
0]

6 3 [2, 0, Yes 1 (used later)

3]

7 0 [2, 0, No -
3]

8 4 [0, 3, Yes 2 (used far later)

4]

Pros:

●​ Guarantees minimum page faults.​

Cons:
●​ Cannot be implemented in real-time as it requires future knowledge.

Step 4: Analyzing the Results

For any given reference string, after applying all algorithms:

1.​ Compare the total page faults.

2.​ Assess which algorithm performed best under the given workload.
3.​ Draw conclusions based on results (e.g., LRU is better for repetitive access patterns).

Step 5: General Observations and Tips

●​ FIFO: Simple but may cause "Belady's anomaly" (increase in page frames doesn't always decrease page
faults).
●​ LRU: Good for real-world applications where past behavior predicts future use.
●​ Optimal: Theoretically the best but impractical due to the need for future knowledge.
Step-by-Step Approach to Solve Disk Scheduling Problems
Disk scheduling algorithms are used to determine the order in which disk I/O requests are processed to minimize
seek time and improve performance.

Given Problem Statement:

●​ Request Queue (Sequence): 95, 180, 34, 119, 11, 123, 62, 64
●​ Initial Head Position: 50
●​ Ending Track (Disk Range): 0 to 199

Step 1: Understanding Key Metrics

For each scheduling algorithm, calculate:

1.​ Seek Distance:​

○​ The total number of tracks the disk arm moves to satisfy all requests.
○​ Seek distance for each move = |current position - next position|.
2.​ Total Seek Time:​

○​ Sum of all seek distances.

Step 2: Applying Different Disk Scheduling Algorithms

1. First-Come, First-Served (FCFS)

Concept:

●​ Serve requests in the order they appear in the queue.

Steps to Solve:

1.​ Start from the initial position 50.

2.​ Process the requests in sequence: 95, 180, 34, 119, 11, 123, 62, 64.
3.​ Calculate total seek distance by summing up the absolute differences between consecutive requests.

Calculation Example:

∣50−95∣+∣95−180∣+∣180−34∣+∣34−119∣+∣119−11∣+∣11−123∣+∣123−62∣+∣62−64∣|50 - 95| + |95 - 180| + |180 -

34| + |34 - 119| + |119 - 11| + |11 - 123| + |123 - 62| + |62 - 64| =45+85+146+85+108+112+61+2=644= 45 + 85 + 146
+ 85 + 108 + 112 + 61 + 2 = 644

Total Seek Distance (FCFS): 644

2. Shortest Seek Time First (SSTF)

Concept:
 ●​ Serve the request closest to the current head position first.

Steps to Solve:

1.​ Start from the initial position 50.

2.​ Find the request that minimizes the seek distance.
3.​ Repeat until all requests are processed.

Calculation Example:

1.​ From 50, the closest request is 34 (distance |50 - 34| = 16).
2.​ From 34, the closest is 62 (distance |34 - 62| = 28).
3.​ Continue until all requests are processed.

Order of Execution:​
50 → 62 → 64 → 34 → 11 → 95 → 119 → 123 → 180

Total Seek Distance (SSTF): 233

3. LOOK (Elevator Algorithm - Bidirectional)

Concept:

●​ The disk arm moves in one direction (towards the nearest end), serving requests until it reaches the last
request in that direction, then reverses.

Steps to Solve:

1.​ Sort the requests: 11, 34, 62, 64, 95, 119, 123, 180.
2.​ Move towards the highest request 180 and serve requests in that direction first.
3.​ Then move backward to the lowest request.

Execution Order (Ascending direction first):​

50 → 62 → 64 → 95 → 119 → 123 → 180 → 34 → 11

Total Seek Distance (LOOK): 226

4. C-LOOK (Circular LOOK)

Concept:

●​ The disk arm moves in one direction and, upon reaching the last request, jumps back to the lowest request
without reversing.

Steps to Solve:

1.​ Sort the requests: 11, 34, 62, 64, 95, 119, 123, 180.
2.​ Move towards the highest request 180, and then jump to the lowest request 11 and continue.
Execution Order:​
50 → 62 → 64 → 95 → 119 → 123 → 180 → (jump to) 11 → 34

Total Seek Distance (C-LOOK): 187

Step 3: Final Results Summary

Algorith Seek Sequence Total Seek
m Distance

FCFS 50 → 95 → 180 → 34 → 119 → 11 → 123 → 62 644

→ 64

SSTF 50 → 62 → 64 → 34 → 11 → 95 → 119 → 123 → 233

180

LOOK 50 → 62 → 64 → 95 → 119 → 123 → 180 → 34 226

→ 11

C-LOOK 50 → 62 → 64 → 95 → 119 → 123 → 180 → 11 187

→ 34

Step 4: General Approach to Solve Any Disk Scheduling Problem

1.​ Understand the Given Inputs:​

○​ Initial head position.

○​ Request sequence.
○​ Range of tracks.
○​ Algorithm to apply.
2.​ Sort Requests (if needed):​

○​ For LOOK, C-LOOK, and SSTF.

3.​ Simulate the Scheduling Algorithm:​

○​ Follow the order of execution based on the algorithm.

○​ Calculate total seek distance.
4.​ Compare Performance:​

○​ Analyze and compare the results to determine which algorithm is optimal for a given workload.

Step 5: Key Observations for Different Algorithms

Algorith When to Use Advantages Disadvantages
m
FCFS General cases with light Fair and simple Poor performance for
loads larger loads

SSTF When minimizing seek Reduces seek time Can cause starvation of
time is critical distant requests

LOOK When bidirectional Avoids unnecessary May not minimize

movement is preferred head movements overall seek time

C-LOOK When a circular pattern Reduces overall seek Jumping can add latency
is needed time