Video summary

Rajasthan Computer Anudeshak Bharti 2026 | Computer- Operating System Concept & MCQ मूलमंत्र क्लास

Main summary

Key takeaways

Educational

Main ideas & concepts covered

1) Operating System: Page Replacement (Mool Mantra Class – Part 3)

  • Primary memory (RAM) is limited; secondary memory (disk) holds the rest.
  • When RAM is full and a new page must be brought in, the OS must evict one existing page.
  • The strategy that decides which page to replace is the page replacement algorithm.
  • Three page replacement algorithms discussed:
    1. FIFO (First-In First-Out)
    2. Optimal Page Replacement
    3. LRU (Least Recently Used)

Key terminology (used across examples)

  • Page fault / miss: occurs when the requested page is not in RAM.
  • Hit: occurs when the requested page is already in RAM.
  • More misses/page faults ⇒ worse performance (CPU works less efficiently).
  • Notation used:
    • Hit marked with a tick
    • Miss marked with a cross

2) FIFO Page Replacement Algorithm (with example)

Method (FIFO)

  • Keep pages in a queue ordered by arrival time.
  • When replacement is needed, evict the oldest page (front of queue).

Example setup

  • Frames: 3 page frames (F1, F2, F3)
  • Reference string: 1 3 1 3 0 3 5 6 3
  • Algorithm: FIFO

Process taught

  • Fill frames initially (first occurrences cause misses).
  • Once full, on each miss, evict the oldest loaded page.

Result stated

  • Total page faults (FIFO example): 6

3) Optimal Page Replacement Algorithm (with example)

Core principle

  • Evict the page that will be needed latest in the future.
  • Called “Optimal” because it assumes perfect future knowledge.
  • Not literally feasible in real systems, but used for exams/analysis.

Method (Optimal)

  • When replacement is needed:
    • Look ahead in the reference string.
    • Evict the page whose next use is farthest (or not used again for the longest time).

Example setup

  • Frames: 4 page frames

  • Reference string (as spoken, with spacing/typos): 7 0 7 0 1 2 0 7 0 1 2 0 3 0 4 3 4 2 3 0 3 2 3

  • Algorithm: Optimal

Process taught

  • Fill frames; on faults with full frames, evict the page with the least-needed-soonest criterion (farthest future).

Result stated

  • Total page faults (Optimal example): 6

4) LRU Page Replacement Algorithm (with example)

Core principle

  • Evict the page that has been used least recently in the past.

Method (LRU)

  • Track recency of page usage.
  • On replacement:
    • Find the page whose last reference time is oldest.
    • Evict the least recently used page.

Instructor’s explanation approach

  • Contrast:
    • Optimal uses future look-ahead
    • LRU uses past recency tracking
  • Extra emphasis:
    • Repeated references to the same page don’t require repeated “history walking”; just identify which page is least recently used at the decision time.

Example setup

  • Frames: 4 page frames

  • Reference string (spoken with minor errors, approximate): 7 0 1 2 0 3 0 4 2 3 0 0 3 2 3

  • Algorithm: LRU

Process taught

  • Determine hits/misses.
  • On each miss when full, evict the page that is oldest in recent-use order.

Result stated

  • Total page faults (LRU example, after correction): 6

5) Theoretical OS MCQs on Scheduling & Process States

After page replacement, the instructor shifts to MCQ-focused scheduling concepts.

(a) Belady’s Anomaly (called “B Lady Anomaly”)

  • Discussed as a phenomenon in FIFO.
  • Claim taught:
    • Increasing the number of page frames should reduce page faults.
    • But FIFO can show the opposite: more frames ⇒ more page faults.
  • Key point:
    • Belady’s anomaly appears only in FIFO, not in LRU or Optimal (as taught in the class).

(b) Starvation in CPU Scheduling

  • Starvation: a process waits indefinitely.
  • Instructor statement:
    • Starvation occurs in SJF (Shortest Job First) and Priority Scheduling.
    • (A distractor about incorrect “sharing across threads” is mentioned.)
  • Prevention: use Aging
    • gradually increase priority (or effectively reduce remaining time)
    • so the process eventually gets CPU time.

(c) Statements involving starvation / scheduling types

  • Shortest remaining time first (SRTF) / preemptive behavior can also lead to starvation (per the explanation).
  • Round Robin is compared with FCFS regarding response time.

(d) Convoy Effect in FCFS

  • Convoy effect (convoy phenomenon):
    • A long process occupies CPU and delays shorter processes.
    • Increases waiting/latency and reduces throughput/CPU utilization.
  • In FCFS, the first process can’t be preempted, so short jobs behind it wait longer.
  • Instructor repeatedly identifies convoy effect as belonging to FCFS.

6) Process States & State Transitions (MCQs)

(a) Incorrect process state

  • Options discussed: New, Running, Waiting, Terminating.
  • One option is stated as incorrect—specifically, the framing where “waiting” is interpreted as merely waiting to be assigned to a processor (i.e., waiting “inside the processor” style wording).
  • Correct framing:
    • Waiting happens due to an I/O request/event, not because the CPU is not assigned in general.

(b) Preemptive scheduling transitions

  • Answers emphasized:
    • Running → Ready (due to preemption)
    • Ready → Running (dispatch)
    • Blocked → Ready after the awaited event completes (Blocked cannot directly move to Running.)

(c) Running → Waiting transition conditions

Transition to waiting occurs when:

  • the process requests I/O, or
  • it is evicted due to preemption by a higher priority.

The instructor marks an option as wrong when eviction/preemption is treated incorrectly as “waiting” rather than returning to ready.

7) Memory Management MCQs

Key points taught:

  • Page fault occurs when the requested page is not present in memory.
  • Paging: stores a process non-contiguously by mapping fixed-size pages.
  • External fragmentation:
    • associated with segmentation (as taught)
    • class concludes it is not present in paging (per MCQ discussion)
  • Fragmentation notes:
    • Contiguous file allocation may cause external and internal fragmentation (as stated).
  • Worst fit vs others:
    • “Finds the largest block” ⇒ Worst fit

Detailed bullet list: Methods / Algorithms and how to apply them

FIFO Page Replacement (First-In First-Out)

  • Maintain pages in a queue ordered by arrival time.
  • On miss with full RAM:
    • Evict the page at the front of the queue (oldest).
    • Insert the requested page into the freed frame.
  • Track:
    • Miss/page fault when requested page isn’t present
    • Hit when it is present

Optimal Page Replacement

  • On miss with full RAM:
    • Look ahead in the reference string.
    • Find the page’s next occurrence in the future.
    • Evict the page whose next use is farthest away (or never used again).
  • Track hits/misses similarly.

LRU Page Replacement (Least Recently Used)

  • Track recency for each page in frames (when it was most recently used).
  • On miss with full RAM:
    • Evict the page with the oldest last-used time (least recently used).
  • Track hits/misses similarly.

Belady’s Anomaly (FIFO-specific concept)

  • Increasing number of frames can, in FIFO, cause increased page faults.
  • Taught as occurring in FIFO, not in LRU/Optimal.

Starvation prevention

  • Use Aging:
    • gradually increase effective priority (or decrease effective remaining time)
    • so the process eventually gets CPU time.

Speakers / sources featured

  • One main speaker/instructor (not named in the subtitles; presumably the course teacher for “Rajasthan Computer Anudeshak Bharti 2026”)

Original video