Turnaround Time (TAT):
TAT = CT – Arrival Time

Waiting Time (WT):
WT = TAT – Burst Time
WT = TAT – CPU burst (for non-preemptive, single burst)

Response Time (RT):
RT = Time of first CPU allocation – Arrival Time

CPU Utilisation:
CPU Util = (Total CPU busy time) / (Total time) × 100%

Throughput:
Throughput = Number of processes completed / Total time

Average TAT / WT / RT:
Average = Sum of individual values / Number of processes

Logical Address split:
For logical address space = 2^n bytes, page size = 2^d bytes:
Page number bits = n – d, Offset bits = d

Number of pages:
Pages = Process size / Page size (round up)

Page Table Size:
Page table entries = Number of pages = 2^(n–d)
Page table size = 2^(n–d) × entry size

Internal Fragmentation (Paging):
Max internal fragmentation = Page size – 1 byte
Average internal fragmentation = Page size / 2

EAT without TLB (single-level page table):
EAT = 2 × ma (one for page table, one for data)

EAT with TLB:
EAT = h × (TLB_time + ma) + (1–h) × (TLB_time + 2×ma)
≈ ma + TLB_time + (1–h) × ma
where h = TLB hit ratio

Two-level: EAT = 3 × ma
Three-level: EAT = 4 × ma

Page Fault Rate for acceptable EAT:
EAT ≤ (1 + x%) × ma
Solve for maximum p

Number of Page Faults:
Depends on reference string and algorithm (trace manually)

Hit Ratio for Page Replacement:
Hit ratio = (References – Page faults) / References

Degree of multiprogramming for stability:
Number of processes = Available frames / Average working set size

Average Rotational Latency:
Avg Rotational Latency = (1/2) × (60,000 / RPM) ms
= 30,000 / RPM ms

Transfer Time:
Transfer Time = Data size / Transfer rate

Rotation Time (1 full rotation):
T_rot = 60,000 / RPM ms

Transfer Time for one sector:
T_transfer = T_rot / Sectors per track

Max file size (Unix inode, 12 direct + 1 SI + 1 DI + 1 TI):
Max size = (12 + k + k² + k³) × Block size

Disk accesses to read a file block (no cache):
Direct block (1–12): 1 (inode) + 1 (data) = 2
Single indirect: 1 + 1 + 1 = 3
Double indirect: 1 + 2 + 1 = 4
Triple indirect: 1 + 3 + 1 = 5

Indexed allocation max file size:
Max size = (Block size / Pointer size) × Block size

FAT size:
FAT size = (Volume size / Cluster size) × FAT entry size

Bitmap size:
Bitmap size = Total blocks / 8 bytes

Necessary condition check (RAG):
Cycle in RAG is NECESSARY but not sufficient for deadlock
Exception: If each resource type has exactly one instance,
cycle ↔ deadlock (both necessary and sufficient)

Banker’s Algorithm – Safe State:
Need[i] = Max[i] – Allocation[i]
A state is safe if a safe sequence exists:
Work ≥ Need[i] → grant → Work += Allocation[i]

For single-instance resources:
Minimum resources for n processes (each needing 1): n (trivially)
Minimum to allow k simultaneously: R = k + (n – k) × 0 = k