Operating System

Answer: (iii) Efficient utilization of CPU resources

Threads are lightweight processes sharing the same address space.
Advantages: lower context-switch overhead, shared memory communication, improved throughput & CPU utilization, responsiveness. Costs actually decreased are memory and creation time, not increased. Options (i), (ii), (iv) list disadvantages which are incorrect.

Answer: (ii) Round Robin

Time-shared (multiprogrammed, interactive) OS needs to give each ready process a short CPU burst in turn so users get prompt response.

• Round Robin (RR) — preemptive, each process gets a fixed time quantum (e.g., 10-100ms); ideal for time-sharing due to fairness and low response time.
• SJF / FCFS — non-preemptive, can cause starvation / convoy effect, not suitable for interactive response.
• Elevator (SCAN) — disk scheduling, not CPU scheduling.

Answer: (ii) READY state

State transition: RUNNING → BLOCKED (waiting for I/O). On I/O completion, interrupt moves process to READY, not directly to RUNNING — it must be rescheduled by short-term scheduler. BLOCKED → READY → RUNNING.

Answer: (iii) Short-term scheduler (CPU scheduler)

• Long-term: selects jobs from job pool to ready queue (controls degree of multiprogramming)
• Medium-term: swapping (suspend/resume)
• Short-term / CPU scheduler: selects process from ready queue and allocates CPU via dispatcher (runs most frequently, must be fast)
• Batch scheduler is not an OS scheduler type.

Answer: (iii) 2^n - 1 new processes (2^n total including parent)

Each fork() doubles the number of processes. Loop for i=1..n fork() creates:

after i=1: 2 processes
after i=2: 4 processes
...
after i=n: 2^n processes total

New processes = total - original parent = 2^n - 1. If question counts the parent as well, answer (iv) 2^n is sometimes marked; strictly new = 2^n -1.

Answer: (ii) Ageing

Ageing gradually increases priority of waiting processes over time, preventing starvation of low-priority jobs. Starvation is the problem, ageing is the solution. Revocation/Relocation are unrelated.

Answer: (iv) Dispatcher

Clarification: Short-term scheduler selects the process; Dispatcher gives control (context switch, switch to user mode, jump to instruction). Many textbooks loosely say Short-term scheduler, but most precise is Dispatcher. If Options force choice between schedulers only, answer (i) Short Term Scheduler. Here dispatcher is listed, so (iv) is most accurate.

Answer: (ii) Kernel-level thread

Kernel threads are managed directly by kernel (visible to scheduler). User-level threads are managed by user library, kernel unaware. Kernel threads allow true parallelism on multicore but have higher creation/scheduling overhead.

Answer: (iv) response time

• Response time = submission to first response (interactive metric)
• Waiting time = total time in ready queue
• Turnaround = submission to completion
• Throughput = jobs per unit time

Answer: (iii) program in execution

Process = program loaded into memory, with PCB, state, resources, execution context. Program on disk is just executable file (passive). Job is generic batch notion.

Answer: (ii) ready queue

Ready queue holds processes in memory ready to execute, waiting for CPU. Job queue holds jobs on disk, waiting to enter memory.

Answer: (i) dispatcher

Dispatcher context-switches to the chosen process: saves old, loads PCB, switches mode, jumps to PC. Scheduler decides, dispatcher acts.

Answer: (ii) ageing

Ageing prevents starvation by incrementally boosting priority. Convoy effect is low-priority holding resource causing others to wait.

(a) Process Control Block (PCB)

PCB is data structure per process maintained by kernel. Contents: Process ID, State (new/ready/running/waiting/terminated), Program Counter, CPU registers, Scheduling info (priority, queue pointers), Memory info (page tables, limits), I/O status (open files, devices), Accounting (CPU time, limits). Kernel uses PCB for context switch.

(b) Schedulers

• Long-term (Job scheduler): selects processes from job pool on disk to ready queue in memory. Controls degree of multiprogramming. Infrequent, slow. Absent in time-sharing.
• Medium-term: swapping — suspends/resumes processes to balance load, moves between memory/disk.
• Short-term (CPU scheduler): selects from ready queue to CPU frequently (ms). Must be fast; dispatcher then context-switches.
  Tradeoff: LT controls admission, MT handles memory pressure, ST ensures responsiveness.

Process

Program in execution — includes code, data, stack, heap, PCB, open files. States: New→Ready→Running→Waiting→Terminated (+suspended).

IPC Models

• Shared Memory: processes share region; fast, needs sync (mutex/semaphore) to avoid race. E.g., POSIX shm.
• Message Passing: kernel-mediated send/receive via direct naming or mailbox/ports. No shared state, good for distributed, overhead due to syscalls. Indirect mailbox decouples.
  Contrast: Shared memory = speed but synchronization burden, tight coupling; Message passing = isolation, suitability for network, automatic sync but copy overhead. Modern hybrids use both.

C program demonstrating fork parent-child

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main(){
 pid_t p = fork();
 if(p < 0){ perror("fork"); return 1; }
 else if(p == 0){
   // Child
   printf("Child: PID=%d, PPID=%d
", getpid(), getppid());
   // child work
 } else {
   // Parent
   printf("Parent: PID=%d, Child PID=%d
", getpid(), p);
   wait(NULL); // wait for child
   printf("Parent: child finished
");
 }
 return 0;
}

Explanation: fork() duplicates process; returns 0 in child, child PID in parent, -1 on error. Parent and child execute concurrently with separate address spaces. wait() synchronizes. Demonstrates that after fork, both continue after fork statement.

User vs Kernel threads

1. Management: ULT by user library (kernel unaware), KLT by kernel.
2. Scheduling: ULT many-to-one, KLT one-to-one/many-to-many.
3. Blocking: one ULT blocks entire process; KLT can schedule another thread of same process.
4. Overhead: ULT lightweight, fast context switch; KLT heavier but true parallelism.

When better: ULT when threads are cooperative, low concurrency, need fast creation (e.g., user-level task pool). KLT when needing blocking I/O, multicore parallelism, priority scheduling.

SJF calculations (Arrival+ Burst)

P1 AT0 BT7, P2 AT2 BT4, P3 AT4 BT1, P4 AT5 BT4.
Non-preemptive SJF: At 0: P1 runs 0-7. At 7, ready P2(4),P3(1),P4(4) → P3 7-8, then P2 8-12, P4 12-16. WT: P1 0, P2 6, P3 3, P4 7 → Avg WT=4. Avg TAT = (7+10+4+11)/4=8.
Preemptive SJF (SRTF): 0-2 P1 (rem5), at2 P2 (4 vs5) → P2? Actually P1 rem5 vs P2 4 → preempt to P2 2-4 (rem2), at4 P3(1) arrives shortest → P3 4-5, back to P2 5-7, P4 arrives 5 (4) vs P1(5) → P4 7-11, P1 11-16. WT: P1 9, P2 1, P3 0, P4 2 → Avg WT=3. Avg TAT=7. Details with Gantt: Non-preemptive Gantt P1|P3|P2|P4, Preemptive P1(0-2)|P2(2-4)|P3(4-5)|P2(5-7)|P4(7-11)|P1(11-16).

Process States & Transition Diagram

States: New (creating), Ready (in memory, waiting CPU), Running (executing), Waiting/Blocked (waiting event/I/O), Terminated (+Suspended ready/blocked via medium-term).
Transitions: New→Ready (admit), Ready→Running (dispatch), Running→Ready (preempt/timeout), Running→Waiting (I/O request), Waiting→Ready (I/O complete), Running→Terminated (exit).
Diagram description: Ready and Running connected bidirectionally, Running to Waiting one-way, Waiting to Ready one-way. Explains multiprogramming and context switch.

Process Scheduling Role

Maximize CPU utilization, throughput, fairness, response time for multiprogramming.

Three Criteria

1. CPU Utilization (% busy)
2. Throughput (jobs/sec)
3. Turnaround / Waiting / Response Time (minimize)
4. Fairness (no starvation)
   Explain tradeoffs: batch favors throughput, interactive favors response.

PCB Structure & Significance

Fields: PID, state, PC, registers, scheduling info, memory management (page table base), I/O info, accounting. Significance: enables context switch, scheduling, process management; kernel's repository for resume. Stored in kernel space per process.

FCFS vs SJF for A(10),B(1),C(2),D(1),E(5) arrival 0

FCFS order A,B,C,D,E: Gantt A0-10,B10-11,C11-13,D13-14,E14-19. WT: A0,B10,C11,D13,E14 => Avg WT=9.6, Avg TAT=13.4
SJF (non-preemptive, sorted by burst): order B(1),D(1),C(2),E(5),A(10): Gantt B0-1,D1-2,C2-4,E4-9,A9-19. WT: B0,D1,C2,E4,A9 => Avg WT=3.2, Avg TAT=7.0
Conclusion: SJF gives minimum avg waiting (3.2 vs 9.6). SJF is optimal for avg WT.

Threads & States

Thread = lightweight process, dispatchable unit, shares address space, files of parent.
States: New, Ready, Running, Blocked, Terminated.

ULT vs KLT

• ULT: managed by user library, many-to-one, fast, kernel unaware, blocking blocks process.
• KLT: managed by kernel, one-to-one, slower but true parallelism, blocking of one KLT not block process. Hybrid many-to-many combines.

User & Kernel Threads

ULT: implemented via thread library (pthreads user-level), TCB in user space, scheduling by library, no kernel trap for switch, cannot exploit multiprocessors, whole process blocks on I/O.
KLT: kernel maintains TCB, scheduling by kernel, can be scheduled on different cores, system calls handle ops. Needs mode switch but supports parallel execution. Modern OS supports hybrid.

Multiprocessor & Real-time Scheduling

Multiprocessor: load sharing, affinity, gang scheduling; approaches: SMP symmetric (each CPU self-schedules) vs master-slave. Need load balancing.
Real-time: hard (deadline must met) vs soft. Algorithms: Rate Monotonic (priority ∝ period), EDF (earliest deadline first), priority inheritance to avoid inversion.

Process State Diagram

Explain 5-state plus suspended: New→Ready (admit), Ready↔Running (dispatch/preempt), Running→Waiting (I/O), Waiting→Ready (completion), Running→Terminated. Medium-term adds Suspend Ready/Blocked. Diagram aids context switch understanding.

RR quantum 4, P1=24,P2=3,P3=3 arrival 0

Gantt: P1 0-4, P2 4-7, P3 7-10, P1 10-14, P1 14-18, P1 18-22, P1 22-24, P1 24-28? Actually P1 needs 6 quanta: 0-4(20 rem),4-7 P2 done,7-10 P3 done,10-14 P1(16),14-18(12),18-22(8),22-26(4),26-30(0). WT: P1 =30-24=6? Wait TAT P1 30, WT 6, P2 WT 4, P3 WT 7 => Avg WT ~5.67. Detailed diagram shows RR fairness.

Threads (a) Lightweight process sharing address space

(b) Process has separate memory/files, heavy; thread shares, fast context, communication via shared memory
(c) Resources: TCB, stack, registers, priority, scheduling info, shared code/data/files with parent process.

Scheduling Objectives

Max utilization, throughput, minimize turnaround/waiting/response, fairness.
Roles as earlier: LT admit, MT suspend, ST dispatch.

SJF as Q72: sorted B1,D1,C2,E5,A10 → Gantt B0-1,D1-2,C2-4,E4-9,A9-19, Avg WT 3.2, proving SJF optimal for avg WT vs FCFS 9.6.

Thread Benefits

• Responsiveness, resource sharing, economy (fast creation), scalability on multicore. Improves throughput, uses blocking I/O without blocking process.

Process State Transitions

As Q13: New→Ready→Running↔Waiting→Terminated, with suspend states. Explained with diagram and events.

PCB as before: PID, state, PC, registers, scheduling, memory, I/O, accounting — kernel's process descriptor for management and context switch.

PCB same as Q29: structure and importance for process management.