PRACTICAL FILE

OF
OPERATING SYSTEM
(TIT 243)

Name: Paritosh Bahuguna.

ID: 60631

1|Page
 [Link] List of Experiments in OS [Link]
Simulate the following CPU scheduling algorithms 3–5
a. FCFS
1. b. SJF
c. ROUND ROBIN
Simulate all file allocation strategies 6–7
a. Sequential
2
b. Indexed

3 Simulate linked file allocation strategy. 8–9

Simulate Multiprogramming with Variable number of Tasks and
4 Multiprogramming with Fixed number of Tasks 10 – 11
12 – 14
5 Simulate Bankers Algorithm for DeadLock Avoidance

6 Simulate Bankers Algorithm for DeadLock Prevention 15 – 17

Simulate the following page replacement algorithms 18 – 20
a. FIFO
7 b. LRU
c. LFU
21 – 22
8 Simulate Paging technique for memory management.

9 Simulate disk scheduling algorithms-Scan,C-Scan. 23 – 24

2|Page
 Practical 1
Practical: Simulate the following CPU scheduling algorithms
d. FCFS
e. SJF
f. ROUND ROBIN
Solution:
We’ll assume the following process set as an example:
Process Arrival Time Burst Time
P1 0 5
P2 1 3
P3 2 8
P4 3 6
We’ll calculate Completion Time (CT), Turnaround Time (TAT), and Waiting Time
(WT) for each process.

 FCFS (First-Come First-Serve)

Processes are scheduled in the order they arrive.
Gantt Chart:
| P1 | P2 | P3 | P4 |
0 5 8 16 22
Now compute Turnaround Time and Waiting Time:
Process Arrival Burst Completion Turnaround Time Waiting Time
Time Time Time (CT - AT) (TAT - BT)
P1 0 5 5 5-0=5 5–5=0
P2 1 3 8 8–1=7 7–3=4
P3 2 8 16 16 – 2 = 14 14 – 8 = 6
P4 3 6 22 22 – 3 = 19 19 – 6 = 13

 SJF (Shortest Job First) – Non-pre-emptive

At each scheduling decision, choose the process with the shortest burst time among
available processes.
Step-by-Step:
1. At t=0, only P1 is available → run P1.

3|Page
 2. After P1 completes at t=5, processes P2, P3, P4 have arrived.
3. Choose the shortest burst: P2 (3).
4. After P2 completes at t=8, choose P4 (6) (since it’s shorter than P3's 8).
5. Finally P3 runs.
Gantt Chart:
| P1 | P2 | P4 | P3 |
0 5 8 14 22
Now compute Turnaround Time and Waiting Time:
Process Arrival Burst Completion Turnaround Time Waiting Time
Time Time Time (CT - AT) (TAT - BT)
P1 0 5 5 5–0=5 5–5=0
P2 1 3 8 8–1=7 7–3=4
P4 3 6 14 14 – 3 = 11 11 – 6 = 5
P3 2 8 22 22 – 2 = 20 20 – 8 = 12

 ROUND ROBIN (quantum = 4)

Let’s use time quantum = 4 units.
Step-by-Step:
Queue initially: [P1, P2, P3, P4]
Start at t=0
1. P1 runs 4 units → remaining 1 → t=4
2. P2 runs 3 units (finishes) → t=7
3. P3 runs 4 units → remaining 4 → t=11
4. P4 runs 4 units → remaining 2 → t=15
5. P1 runs 1 unit (finishes) → t=16
6. P3 runs 4 units (finishes) → t=20
7. P4 runs 2 units (finishes) → t=22
Gantt Chart:
| P1 | P2 | P3 | P4 | P1 | P3 | P4 |
0 4 7 11 15 16 20 22
Completion Times:

4|Page
Process Completion Time

P1 16

P2 7

P3 20

P4 22
Now compute Turnaround Time and Waiting Time:
Process Arrival Burst Completion Turnaround Time Waiting Time
Time Time Time (CT - AT) (TAT - BT)
P1 0 5 16 16 – 0 = 16 16 – 5 = 11
P2 1 3 7 7–1=6 6–3=3
P3 2 8 20 20 – 2 = 18 18 – 8 = 10
P4 3 6 22 22 – 3 = 19 19 – 6 = 13

5|Page
 Practical 2
Practical: Simulate all file allocation strategies
c. Sequential
d. Indexed
Solution:
We’ll assume a simple disk with 20 blocks (0 to 19).
Let’s say we want to allocate the following files:
Fil Length (Blocks)
e
F1 5
F2 3
F3 4
We will manually allocate blocks for each strategy.

 Sequential Allocation
In sequential allocation, each file is allocated contiguous blocks on the disk.
Let’s assume we start allocating from block 0:
File Start Block Allocated Blocks
F1 0 0,1,2,3,4
F2 5 5,6,7
F3 8 8,9,10,11
 Files occupy continuous memory.
 Easy access since we just need the start block and length.
Directory Table:
File Start Length
Block
F1 0 5
F2 5 3
F3 8 4
Example: To access the 3rd block of F1 → block = 0 + (3-1) = 2.

6|Page
 Indexed Allocation
In indexed allocation, each file has an index block that stores the addresses of all its data
blocks.
Let’s assign index blocks arbitrarily:
Fil Index Block Allocated Data Blocks
e
F1 0 2, 4, 5, 9, 12
F2 1 3, 6, 11
F3 7 8, 10, 13, 15
 The index block contains pointers to the actual data blocks.
 The data blocks need not be contiguous or ordered.
Directory Table:
Fil Index Block
e
F1 0
F2 1
F3 7
The content of index blocks:
 Index Block 0: [2, 4, 5, 9, 12]
 Index Block 1: [3, 6, 11]
 Index Block 7: [8, 10, 13, 15]
Example: To access 4th block of F1 → follow index block 0 → get block 9.

7|Page
 Practical 3
Practical: Simulate linked file allocation strategy.
Solution:
Linked Allocation
In linked allocation,
 Each file is a linked list of disk blocks.
 Each block contains data + pointer to the next block.
 Blocks are scattered anywhere on disk, no need to be contiguous.
We’ll assume a disk with 20 blocks (0 to 19).
We want to allocate:
Fil Length (Blocks)
e
F1 5
F2 3
F3 4

Block Allocation Example

Let’s assign random blocks:
Fil Allocated Blocks (Linked List)
e
F1 4 → 7 → 9 → 11 → 15
F2 2 → 5 → 12
F3 8 → 10 → 13 → 16
Each block contains:
1. Data
2. Pointer to next block
The last block’s pointer is null (end of file).

Directory Table:
We just need to store starting block for each file:

8|Page
 File Starting Block
F1 4
F2 2
F3 8

How to access data?

 To access a block of a file,
start from starting block and follow pointers till desired block.
Example:
To access 3rd block of F1:
Start at 4 → next = 7 → next = 9 (3rd block)

Visualization:
File F1:
4 --> 7 --> 9 --> 11 --> 15 --> NULL
File F2:
2 --> 5 --> 12 --> NULL
File F3:
8 --> 10 --> 13 --> 16 --> NULL

9|Page
 Practical 4
Practical: Simulate Multiprogramming with Variable number of Tasks and Multiprogramming
with Fixed number of Tasks
Solution:
Assumptions:
 Total main memory = 1000 KB
 OS occupies 100 KB
→ Available memory = 900 KB
We have the following jobs:
Job Size (KB)
J1 150
J2 300
J3 200
J4 350
J5 100

 Multiprogramming with Fixed number of Tasks (MFT)

In MFT:
 Memory is divided into fixed-size partitions
 One job per partition
 If a job is smaller than partition → internal fragmentation
Let’s divide memory into 4 fixed partitions of 225 KB each (since 900/4 = 225):
Partition Size (KB) Allocated Job Wasted Space
P1 225 J1 225-150=75
P2 225 J3 225-200=25
P3 225 J5 225-100=125
P4 225 J2 225-300=Cannot fit → Skipped
 J2 (300 KB) and J4 (350 KB) → do not fit into 225 KB partition
 Internal Fragmentation Total = 75 + 25 + 125 = 225 KB
MFT Summary:
 J1, J3, J5 are loaded
 J2, J4 cannot be loaded

10 | P a g e
  225 KB wasted as internal fragmentation

 Multiprogramming with Variable number of Tasks (MVT)

In MVT:
 Memory allocated dynamically based on job size
 No fixed partitions → no internal fragmentation
Let’s allocate jobs one by one:
1. Available = 900 KB
2. Allocate J1 (150 KB) → Remaining = 750 KB
3. Allocate J2 (300 KB) → Remaining = 450 KB
4. Allocate J3 (200 KB) → Remaining = 250 KB
5. Allocate J4 (350 KB) → Cannot fit → needs 350, only 250 left
6. Allocate J5 (100 KB) → Remaining = 150 KB
Job Allocated? Memory Remaining
J1 Yes 750 KB
J2 Yes 450 KB
J3 Yes 250 KB
J4 No -
J5 Yes 150 KB
 No internal fragmentation!
 External fragmentation possible (since 150 KB free but J4 needs 350 KB)

11 | P a g e
 Practical 5
Practical: Simulate Bankers Algorithm for Deadlock Avoidance
Solution:
Step 1: Problem Setup
Let’s assume:
 5 processes: P0, P1, P2, P3, P4
 3 resource types: A, B, C
Given Matrices:
Process Allocation (A,B,C) Max (A,B,C)
P0 010 753
P1 200 322
P2 302 902
P3 211 222
P4 002 433
 Available resources (A,B,C) = (3, 3, 2)

Step 2: Calculate Need Matrix

Need=Max−Allocation Need = Max - Allocation Need=Max−Allocation
Process Need (A,B,C)
P0 743
P1 122
P2 600
P3 011
P4 431

Step 3: Check for Safe Sequence

We start with:
→ Work = Available = (3,3,2)
→ Finish = [False, False, False, False, False]
Let’s check if a process can finish:

12 | P a g e
Check P0:
Need (7,4,3) > Work (3,3,2) → ❌ cannot proceed
Check P1:
Need (1,2,2) ≤ Work (3,3,2) → ✅ can proceed
→ Allocate P1:
→ New Work = Work + Allocation = (3+2, 3+0, 2+0) = (5,3,2)
→ Finish[P1] = True

Check P0 again:
Need (7,4,3) > Work (5,3,2) → ❌ cannot proceed
Check P2:
Need (6,0,0) > Work (5,3,2) → ❌ cannot proceed
Check P3:
Need (0,1,1) ≤ Work (5,3,2) → ✅ can proceed
→ Allocate P3:
→ New Work = (5+2, 3+1, 2+1) = (7,4,3)
→ Finish[P3] = True

Check P0 again:
Need (7,4,3) ≤ Work (7,4,3) → ✅ can proceed
→ Allocate P0:
→ New Work = (7+0, 4+1, 3+0) = (7,5,3)
→ Finish[P0] = True

Check P2:
Need (6,0,0) ≤ Work (7,5,3) → ✅ can proceed
→ Allocate P2:
→ New Work = (7+3, 5+0, 3+2) = (10,5,5)
→ Finish[P2] = True

Check P4:
Need (4,3,1) ≤ Work (10,5,5) → ✅ can proceed

13 | P a g e
→ Allocate P4:
→ New Work = (10+0,5+0,5+2) = (10,5,7)
→ Finish[P4] = True

All processes can finish → SYSTEM IS IN SAFE STATE

 Safe Sequence = P1 → P3 → P0 → P2 → P4

14 | P a g e
 Practical 6
Practical: Simulate Bankers Algorithm for Deadlock Prevention
Solution:
Banker’s Algorithm is actually a Deadlock Avoidance algorithm, not prevention (deadlock
prevention uses different methods like pre-emption, hold & wait avoidance, etc.).
Problem Setup
We have:
 3 resource types: A, B, C
 5 processes: P0, P1, P2, P3, P4

Initial Matrices:
Process Allocation (A,B,C) Max (A,B,C)
P0 010 753
P1 200 322
P2 302 902
P3 211 222
P4 002 433
Available resources: (A,B,C) = (3,3,2)

Step 1: Compute Need Matrix

Need=Max−allocation Need = Max - allocation Need=Max−Allocation
Process Need (A,B,C)
P0 743
P1 122
P2 600
P3 011
P4 431

Step 2: Safe Sequence Check

We start with:
 Work = Available = (3,3,2)

15 | P a g e
  Finish = [False, False, False, False, False]

Check P0:
Need (7,4,3) > Work (3,3,2) → ❌ cannot proceed
Check P1:
Need (1,2,2) ≤ Work (3,3,2) → ✅ can proceed
→ Allocate P1 →
New Work = Work + Allocation = (3+2, 3+0, 2+0) = (5,3,2)
→ Finish[P1] = True

Check P0 again:
Need (7,4,3) > Work (5,3,2) → ❌
Check P2:
Need (6,0,0) > Work (5,3,2) → ❌
Check P3:
Need (0,1,1) ≤ Work (5,3,2) → ✅
→ Allocate P3 →
New Work = (5+2, 3+1, 2+1) = (7,4,3)
→ Finish[P3] = True

Check P0 now:
Need (7,4,3) ≤ Work (7,4,3) → ✅
→ Allocate P0 →
New Work = (7+0, 4+1, 3+0) = (7,5,3)
→ Finish[P0] = True

Check P2:
Need (6,0,0) ≤ Work (7,5,3) → ✅
→ Allocate P2 →
New Work = (7+3, 5+0, 3+2) = (10,5,5)
→ Finish[P2] = True

Check P4:

16 | P a g e
Need (4,3,1) ≤ Work (10,5,5) → ✅
→ Allocate P4 →
New Work = (10+0, 5+0, 5+2) = (10,5,7)
→ Finish[P4] = True

All processes finished → SYSTEM IS IN SAFE STATE

 Safe Sequence: P1 → P3 → P0 → P2 → P4
 No deadlock will occur if requests stay within maximum declared resources.

17 | P a g e
 Practical 7
Practical: Simulate the following page replacement algorithms
a. FIFO
b. LRU
c. LFU
Solution:
Given:
 Reference String:
7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2
 Number of frames = 3

 FIFO (First-In-First-Out)
We replace the oldest page first.
Let’s process:
Step Ref Frame Content Page Fault?
1 7 7 Fault
2 0 70 Fault
3 1 701 Fault
4 2 012 Fault (7 out)
5 0 012 -
6 3 123 Fault (0 out)
7 0 230 Fault (1 out)
8 4 304 Fault (2 out)
9 2 042 Fault (3 out)
10 3 423 Fault (0 out)
11 0 230 Fault (4 out)
12 3 230 -
13 2 230 -
 Total Page Faults (FIFO) = 9

 LRU (Least Recently Used)

18 | P a g e
 We replace the page that was least recently used.
Step Ref Frame Content Page Fault?
1 7 7 Fault
2 0 70 Fault
3 1 701 Fault
4 2 012 Fault (7 out)
5 0 012 -
6 3 123 Fault (0 out)
7 0 230 Fault (1 out)
8 4 304 Fault (2 out)
9 2 042 Fault (3 out)
10 3 423 Fault (0 out)
11 0 230 Fault (4 out)
12 3 230 -
13 2 230 -
 Total Page Faults (LRU) = 10
(NOTE: identical to FIFO in this example — sometimes possible)

 LFU (Least Frequently Used)

We replace the least frequently used page (if tie → FIFO or LRU policy resolves).
Step Ref Frame Content Frequency Page Fault?
1 7 7 7→1 Fault
2 0 70 7→1, 0→1 Fault
3 1 701 7→1, 0→1, 1→1 Fault
4 2 012 0→1, 1→1, 2→1 Fault (7 out)
5 0 012 0→2, 1→1, 2→1 -
6 3 023 0→2, 2→1, 3→1 Fault (1 out: least freq 1)
7 0 023 0→3, 2→1, 3→1 -
8 4 034 0→3, 3→1, 4→1 Fault (2 out: least freq 1)
9 2 042 0→3, 4→1, 2→1 Fault (3 out: least freq 1)

19 | P a g e
 10 3 023 0→3, 2→1, 3→1 Fault (4 out: least freq 1)
11 0 023 0→4, 2→1, 3→1 -
12 3 023 0→4, 2→1, 3→2 -
13 2 023 0→4, 2→2, 3→2 -
 Total Page Faults (LFU) = 9

20 | P a g e
 Practical 8
Practical: Simulate Paging technique for memory management.
Solution:
What is Paging?
In paging, physical memory is divided into fixed-size frames and logical memory into pages
of the same size.
 Each page is mapped to a frame via a page table.

Example Setup:
 Logical Address Space = 8 pages (0-7)
 Physical Memory = 32 frames (0-31)
 Page size = 1 KB (each page/frame = 1 KB)
Suppose the following page table:
Page No Frame No
0 5
1 9
2 17
3 1
4 8
5 20
6 4
7 12

Virtual Address:
Suppose a process generates the logical address:
Logical Address = 3 KB + 300 bytes
 Page size = 1 KB →
→ Page Number = 3 (since 3 KB falls in page 3)
→ Offset = 300 bytes

Find Physical Address:

→ From page table:

21 | P a g e
Page 3 is in Frame 1
Physical Address formula:
Physical Address = (Frame Number X Frame Size) + Offset
Substitute:
Physical Address = (1 X 1024) + 300
Physical Address = 1024 + 300 = 1324
 Physical Address = 1324 bytes

Explanation:
→ Logical address 3 KB + 300 bytes → mapped to Frame 1 → → Physical Address = 1324
bytes

22 | P a g e
 Practical 9
Practical: Simulate disk scheduling algorithms-Scan, C-Scan.
Solution:
Problem Setup:
 Disk queue of requests:
82, 170, 43, 140, 24, 16, 190
 Initial head position = 50
 Disk size = 200 tracks (0–199)
 Head moves toward higher track numbers first

A. SCAN (Elevator Algorithm):

Head moves in one direction → serves requests → reverses at end → serves in opposite
direction.
Step 1: Sort requests
Requests: 16, 24, 43, 82, 140, 170, 190
Head at 50, moving toward higher tracks first:
 Serve in ascending order until end:
→ 82 → 140 → 170 → 190 → then reverse → 43 → 24 → 16
(Also, end boundary is 199 if you go to end)
But in SCAN → reverses only when no more requests → no need to go till 199
Order of service:
50 → 82 → 140 → 170 → 190 → reverse → 43 → 24 → 16

Distance travelled:
1. 50 → 82 = 32
2. 82 → 140 = 58
3. 140 → 170 = 30
4. 170 → 190 = 20
5. 190 → 43 = (reverse) → 147
6. 43 → 24 = 19
7. 24 → 16 = 8
 Total distance:

23 | P a g e
 32 + 58 + 30 + 20 + 147 + 19 + 8 = 314

B. C-SCAN (Circular SCAN):

 Head moves in one direction → serves requests → reaches end → jumps to beginning
→ continues in same direction
Order of service:
50 → 82 → 140 → 170 → 190 → (go to end 199) → jump to 0 → 16 → 24 → 43
 After 190, move to end (199) → jump to 0 → continue
Distance travelled:
1. 50 → 82 = 32
2. 82 → 140 = 58
3. 140 → 170 = 30
4. 170 → 190 = 20
5. 190 → 199 = 9 (move to end)
6. 199 → 0 = 199 (jump)
7. 0 → 16 = 16
8. 16 → 24 = 8
9. 24 → 43 = 19
 Total distance:
32 + 58 + 30 + 20 + 9 + 199 + 16 + 8 + 19 = 391

24 | P a g e