Solution

• FCFS (First Come First Serve): Executes in the order processes arrive, no burst-time consideration.

• SJF (Shortest Job First): Picks the process with the least CPU burst time → minimizes average waiting time.

• Round Robin: Allocates equal time slices (quantum) cyclically, ignoring burst length.

• Priority Scheduling: Selects based on priority value, not burst time (though burst time can be used as a priority heuristic).

Solution

For a deadlock to occur in a system, the following Coffman’s conditions must all hold together:

1. Mutual Exclusion – At least one resource must be held in a non-shareable mode.

2. Hold and Wait – A process holding resources is waiting for additional resources.

3. No Preemption – Resources cannot be forcibly taken away; they are released only voluntarily.

4. Circular Wait – A closed chain of processes exists, each waiting for a resource held by the next process in the chain.

If even one of these is not satisfied, deadlock cannot occur.

Solution

Use of semaphores ✅

Because the Dining Philosopher problem is a classical synchronization problem, and it is solved using semaphores / monitors / mutex locks.

• Overlays → related to memory management, not correct.

• Mutual exclusion → is a requirement, but the standard answer in MCQs is semaphores.

• Bounded waiting → is a condition, not the actual solution technique.

So the correct choice from the given options is "Use of semaphores."

Solution

Solution

Let’s analyze the options:

1. Process termination ✅

   • This is indeed a way to recover from a deadlock after it has already occurred (kill one or more processes to break the cycle).

2. Non-preemption of resources ❌

   • This is a deadlock prevention method, not recovery.

3. Banker’s algorithm ❌

   • This is a deadlock avoidance technique, not recovery.

4. Circular wait ❌

   • This is one of the necessary conditions for deadlock, not a recovery method.

Solution

Using LRU with 3 frames on the string
7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2
gives page faults at: 7, 0, 1, 2, 3, 4, 2, 3, 0 → 9 faults.

Solution

Solution

Explanation:

• SSTF (Shortest Seek Time First): Always serves the request that requires the minimum head movement from the current head position.

• LOOK/SCAN: Move in one direction (like elevators), serving requests along the way.

• FCFS: Serve requests in the order they arrive.

✅ Hence, SSTF is the correct choice.

Solution

The general structure of a process with critical section is:

1. Entry section → request entry into the critical section.

2. Critical section → perform the critical task.

3. Exit section → leave and update status.

4. Remainder section → execute non-critical code.

Solution

In MS-DOS, the layering from innermost to outermost is:

1. ROM BIOS Device Drivers (lowest-level hardware interaction)

2. MS-DOS Device Drivers (software drivers loaded by OS)

3. Resident System Program (command.com, kernel parts)

4. Application Program (user programs)

Solution

Solution

List-I (Algorithms) and their correct features:

• (A) FCFS (First Come First Serve) → It is non-preemptive and can cause long average waiting time if a long job arrives first.
  ⇒ Matches with (III).

• (B) Round Robin → It is essentially FCFS with preemption (time quantum).
  ⇒ Matches with (I).

• (C) Multi-level queue scheduling → Each process is permanently assigned to a fixed queue (like system, interactive, batch).
  ⇒ Matches with (IV).

• (D) Multi-level feedback queue → Allows processes to move between queues depending on behavior/CPU burst.
  ⇒ Matches with (II).

Correct Matching:

Solution

• BFS (Breadth First Search) on an unweighted graph always explores level by level.
  ⇒ BFS always finds the shortest path. → (A) True

• DFS (Depth First Search) explores deeply before backtracking. It can find a path, but not necessarily the shortest one.
  ⇒ DFS does not guarantee shortest path. → (C) True

• (B) “DFS always finds the shortest path” → ❌ False.

• (D) “BFS does not guarantee shortest path” → ❌ False.

✅ Correct Answer:

Solution

Solution

We are asked about FIFO (First-In First-Out) page replacement algorithm.

Key point:

• Normally, increasing the number of page frames decreases the number of page faults (because more pages can be stored).

• But in FIFO, there is a special anomaly called Belady’s Anomaly.

  • It states that in FIFO, sometimes increasing the number of page frames may actually increase the number of page faults (depending on the access pattern).

Checking the options:

1. Increasing the number of page frames decreases the number of page faults.
   ❌ Not always true (Belady’s anomaly exists).

2. Increasing the number of page frames may increase or decrease the number of page faults depending on the memory access pattern.
   ✅ This is correct (captures Belady’s anomaly).

3. Increasing the number of page frames always increases the number of page faults.
   ❌ Wrong.

4. Increasing the number of page frames has no effect.
   ❌ Wrong.

✅ Final Answer:
(2) Increasing the number of page frames may increase or decrease the number of page faults depending on the memory access pattern.

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution