User Thread vs Kernel Thread

Given Data

Quantum $= 2$.

(a) FCFS

Order by arrival: C(0), B(1), A(2), D(3), E(4).

$$\text{Avg TAT} = \frac{1+11+19+20+26}{5} = \frac{77}{5} = 15.4$$

$$\text{Avg WT} = \frac{0+0+10+18+19}{5} = \frac{47}{5} = 9.4$$

(b) Round Robin (Quantum = 2)

Enqueue rule: a newly arriving process is added to the ready queue before the just-preempted process is re-added.

Tracing:

• t=0: only C ready. Run C(1) → t=1, C done.
• t=1: B arrives, queue [B]. Run B → t=3, B rem 9. During run, A arrives at 2, D arrives at 3. Queue after adding arrivals then B: [A, D, B].
• t=3: Run A → t=5, A rem 7. E arrives at 4. Queue: [D, B, E, A].
• t=5: Run D(2) → t=7, D done. Queue: [B, E, A].
• t=7: Run B → t=9, B rem 7. Queue: [E, A, B].
• t=9: Run E → t=11, E rem 5. Queue: [A, B, E].
• t=11: Run A → t=13, A rem 5. Queue: [B, E, A].
• t=13: Run B → t=15, B rem 5. Queue: [E, A, B].
• t=15: Run E → t=17, E rem 3. Queue: [A, B, E].
• t=17: Run A → t=19, A rem 3. Queue: [B, E, A].
• t=19: Run B → t=21, B rem 3. Queue: [E, A, B].
• t=21: Run E → t=23, E rem 1. Queue: [A, B, E].
• t=23: Run A → t=25, A rem 1. Queue: [B, E, A].
• t=25: Run B → t=27, B rem 1. Queue: [E, A, B].
• t=27: Run E(1) → t=28, E done. Queue: [A, B].
• t=28: Run A(1) → t=29, A done. Queue: [B].
• t=29: Run B(1) → t=30, B done.

Gantt Chart:

C | B | A | D | B | E | A | B | E | A | B | E | A | B | E | A | B
0 1   3   5   7   9  11  13  15  17  19  21  23  25  27 28 29 30

Completion / TAT / WT

$$\text{Avg TAT} = \frac{1+29+27+4+24}{5} = \frac{85}{5} = 17.0$$

$$\text{Avg WT} = \frac{0+18+18+2+17}{5} = \frac{55}{5} = 11.0$$

Summary

Watch the Round Robin queue order: using the standard enqueue convention (new arrivals join the ready queue before the preempted process), B finishes at 30 and A at 29, giving Avg TAT = 17.0 and Avg WT = 11.0. A different enqueue order, for example running D at t = 6 to 8, gives finish times B = 29 and A = 27 instead. FCFS is unaffected.

Page Fault and Page Replacement Algorithms

When Does a Page Fault Occur?

A page fault occurs when a process references a page that is not currently present in main memory (RAM). The CPU generates a trap, and the OS must bring the required page from secondary storage into a frame. If no free frame exists, a page replacement algorithm chooses a victim to evict.

Given Data

• Reference string: 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 3
• Number of frames: 4
• Total references: 14

1. Optimal Page Replacement

Replace the page not needed for the longest time in the future.

At ref 3 (index 6), page 1 is never used again → evict 1.
At ref 4, remaining future refs: 2,3,0,3,2,3. Page 7 never used again → evict 7.

Optimal Page Faults = 6

2. FIFO Page Replacement

Replace the oldest loaded page.

FIFO Page Faults = 7

3. Second Chance (Clock) Page Replacement

FIFO order maintained, but on a hit the reference bit R is set to 1. When selecting a victim, if the oldest page has R=1, clear it to 0 and move it to the back (give it a second chance); if R=0, replace it.

Notation: page(R).

Step detail at ref 4: clock pointer at oldest = 0 (R=1) → set R=0, advance; page 1 (R=0) → victim. Result frames = {2,3,0,4}. This matches FIFO's replacement here because giving 0 a second chance saved it.

Second Chance Page Faults = 6

Summary

System Call: Definition and Objectives

Definition

A system call is a programmatic way in which a computer program requests a service from the kernel of the operating system. It provides an interface between a user-level process and the operating system, allowing user programs to request OS services that require higher privilege levels (kernel mode) than the user mode in which normal programs run.

In simple terms, a system call is a controlled entry point into the kernel through which a running program can ask the OS to perform operations on its behalf.

Example: When a program wants to read a file, it issues a read() system call rather than directly accessing the hardware.

Objectives of System Calls

System calls serve the following key objectives:

1. Hardware Abstraction

System calls hide the complexity of hardware from user programs. Programmers do not need to know the details of hardware devices; they simply call standard system call interfaces.

2. Protection and Security

They ensure that user programs cannot directly access hardware or critical OS resources. The OS validates each request, preventing unauthorized or harmful operations.

3. Resource Management

System calls allow the OS to manage and allocate resources (CPU, memory, I/O devices, files) in a controlled and fair manner among multiple processes.

4. Mode Switching (User Mode to Kernel Mode)

System calls provide a safe and controlled mechanism to switch from user mode to kernel mode, so that privileged instructions can be executed only under OS supervision.

5. Process Control

They allow user programs to create, terminate, and manage processes and threads (e.g., fork(), exec(), exit()).

6. Inter-Process Communication (IPC)

System calls provide mechanisms for processes to communicate and synchronize with each other (e.g., pipes, message queues, shared memory).

7. File and I/O Operations

They provide a standard interface for file management and input/output operations such as open(), read(), write(), and close().

Summary Table

In conclusion, system calls act as the bridge between user applications and the operating system kernel, ensuring security, abstraction, and controlled access to system resources.

Virtual Machine and System Protection

Virtual Machine (2 marks)

A virtual machine (VM) is a software emulation of a physical computer system that provides a virtual environment in which an operating system or application can run as if it were running on dedicated physical hardware.

A virtual machine creates an illusion of a complete hardware system (including CPU, memory, storage, and network interfaces) on top of actual physical hardware. Multiple virtual machines can run simultaneously on a single physical machine, each isolated from the others.

Key characteristics:

• Each VM runs its own operating system (called guest OS)
• The underlying physical machine runs a host OS or hypervisor
• VMs are isolated from each other, providing security and stability
• Examples: VMware, VirtualBox, Hyper-V

+------------------+  +------------------+
|   Guest OS 1     |  |   Guest OS 2     |
+------------------+  +------------------+
|        Virtual Machine Monitor (VMM)   |
+----------------------------------------+
|         Physical Hardware              |
+----------------------------------------+

System Protection (3 marks)

System protection refers to mechanisms and policies used by an operating system to control access to resources (CPU, memory, I/O devices, files) and prevent unauthorized or accidental interference between processes and users.

Goals of System Protection:

• Prevent unauthorized access to system resources
• Ensure each process accesses only what it is permitted to
• Detect and prevent errors that could compromise system integrity

Key Concepts in System Protection:

1. Protection Domains

• A protection domain defines a set of resources and the access rights (read, write, execute) a process has over those resources.
• A process operates within a domain and can only access objects permitted in that domain.
• Domains can be associated with users, processes, or procedures.

2. Access Matrix

• An access matrix is a model for protection where:
  • Rows represent domains (users/processes)
  • Columns represent objects (files, devices)
  • Entries define allowed operations (read, write, execute)

3. Dual Mode Operation

• Hardware support for protection through user mode and kernel mode
• Privileged instructions can only execute in kernel mode
• Prevents user processes from directly accessing hardware

4. Memory Protection

• Ensures a process cannot access memory belonging to another process or the OS
• Implemented using base and limit registers or paging/segmentation

5. CPU Protection

• Timer interrupts prevent a process from monopolizing the CPU
• The OS regains control after a set time interval

Summary:

System protection ensures controlled access, isolation, and integrity of resources, making the system reliable and secure for multiple users and processes.