৪৯তম বিসিএস ⎯ কম্পিউটার সায়েন্স (CSE) [৯৭১]

Answer: b)
Explanation:
Definition: An OS is system software that manages hardware resources (CPU, memory, I/O) and provides abstractions and services (files, processes) to applications. Intermediate: It schedules tasks, mediates access to devices, and offers APIs (system calls).
Standard: While performance is important, OS design balances resource utilization, concurrency, security, and usability — not simply maximizing raw CPU speed.
Other options:
(a)—OS does not change clock frequency;
(c) —OS supports, not replaces, applications;
(d) —OS runs on many device types.

Answer: c)
Explanation:
Core OS components include process scheduler, memory manager, file system, device drivers, and I/O manager. Intermediate: A compiler translates high-level language to machine code — it's application-level tool, not part of OS kernel. Standard: Some OS distributions include toolchains, but they are not kernel components. Other options are integral OS modules.

Answer: d) Multithreaded kernel
Explanation:

(a)  Monolithic = all OS services in one large kernel.

(b)  Microkernel = minimal kernel, rest in user space.

(c)  Hybrid = mix of both.

(d)  "Multithreaded kernel" is not a kernel type (though kernels may support multithreading).

Answer: d)
Explanation:
Batch OS ran jobs (programs + data) in groups without user interaction. IUsed job control language, job queues, and were popular on early mainframes to improve throughput.  They optimize throughput and resource utilization, not interactivity.

Answer: b)
Explanation:
Definition: Time-sharing systems divide CPU time into slices and rapidly switch among users/processes.  Provide interactive response, typically via terminals; require scheduling and context-switch overhead management. Standard: Time-sharing often introduced features like process isolation and fair scheduling.

(c) false—many time-sharing systems use virtual memory;
(d) contradicts time-sharing;
(a) irrelevant

Answer: b)
Explanation:
Definition: Distributed OS coordinates resources across machines to appear as one cohesive system. It handles transparency (location, migration), distributed scheduling, and failure handling. Requires networking protocols and consistency mechanisms;.

Answer: a)
Explanation:
Definition: PCB holds all information needed to manage a process: PID, state, program counter, registers, memory map, open files. Intermediate: On context switch, kernel saves/restores PCB to resume process. Standard: Not source code or OS kernel

Answer: c)
Explanation:
Short-term scheduler (dispatcher) picks ready process to execute on CPU frequently. 
Needs to be fast, often in microseconds. 
Long-term (job admission) and medium-term (swapping) have different roles

Explanation:
Context switch saves process state (PC, registers) into PCB, restores next process's state.
 Overhead includes time to save/restore and flush TLBs.
Minimizing unnecessary context switches is a performance concern.

Answer: b)
Explanation:
Dispatcher latency includes context-switch time and time to start executing next process.
Smaller latency improves responsiveness. Kernel design aims to minimize this.

Answer: a)
Explanation:
Round Robin gives each ready process a time slice in cyclic order with equal quantum, fairness is achieved; performance depends on quantum size.

Answer: c)
Explanation:

Thread = lightweight process; multiple threads of a process share memory and file descriptors.
 Threads allow concurrency with lower context-switch cost; require synchronization. 
 Processes have PCBs; threads may have TCBs;

Answer: b)
Explanation:
Threads permit parallelism within process; while one thread blocks on I/O, others can run. 
Lower creation and switching overhead than processes. 
Synchronization is needed but not mandatory global locking;

Answer: b)
Explanation:

Non-preemptive scheduling means once a process starts executing on the CPU it keeps the CPU until it either finishes or voluntarily blocks (e.g. for I/O). The scheduler does not forcibly take the CPU away because a new process arrived or a timer expired.
FCFS (First-Come, First-Served) is non-preemptive by design. obeys exactly that rule: processes are served in arrival order and each runs to completion (or until it blocks). So FCFS is non-preemptive by definition.

Other choices are preemptive:

Round Robin (a) — preemptive: a running process is interrupted after a fixed time quantum and put back in the ready queue (time-slice preemption).
SRTF (c) — preemptive: “Shortest Remaining Time First” is the preemptive version of SJF; a new arrival with smaller remaining time will preempt the current process.
Preemptive priority scheduling (d) — the name says it: a higher priority arrival can preempt a lower-priority running task.

Answer: c) Starvation
Priority Scheduling
In priority scheduling, each process is assigned a priority. Higher priority processes are executed first.
Lower priority processes may have to wait indefinitely if higher-priority processes keep arriving.
 What is Aging?
Aging is a technique to prevent starvation. It gradually increases the priority of waiting processes over time.
Eventually, a low-priority process will become high enough to get CPU time.

Priority scheduling + aging → starvation prevention.

Priority scheduling alone → can cause starvation.
Aging adjusts priority dynamically → ensures fairness.

Others option:

a) Deadlock --Aging does not prevent deadlocks. Deadlocks depend on resource allocation cycles, not just priority.

b) Increased throughput always --Aging may slightly reduce throughput in some cases because CPU may be given to previously low-priority processes.

d) Decreased context switches --Aging doesn’t reduce context switches. It affects which process gets scheduled, not the number of switches.

Answer: b)  
Interactive response time: How fast a system responds to user inputs (like typing, mouse clicks, commands).
Round Robin: Each process gets a time slice (quantum) in cyclic order.
Small quantum: Each process gets CPU frequently. Short tasks finish quickly, improving interactive response time.
   Fair and predictable.
Example:
Processes (CPU burst in ms):
Process    Burst
 P1             4
 P2             2
 P3             6

   Quantum = 2 ms → each process runs max 2 ms per turn.
   Interactive users see frequent responses, no process waits too long.

Answer: c) 

Throughput = Number of processes completed per unit time.
Goal of a CPU scheduler: maximize throughput while keeping CPU and I/O busy.
Factors affecting throughput:
 → CPU utilization
 → I/O utilization
 → Number of processes in memory (degree of multiprogramming)

Degree of multiprogramming = Number of processes in memory at the same time.
Effect: More processes → CPU is less likely to be idle → better throughput.
Example: 
1 process → CPU may be idle during I/O.
5 processes → while some are waiting for I/O, others use CPU → higher throughput.

Answer: b) 
Scenario: You have a set of jobs with specific deadlines.

Goal: Minimize maximum lateness, i.e., ensure no job is excessively late.

Lateness (L) of a job = Completion time − Due date

If L > 0 → job is late.
Maximum lateness = the largest lateness among all jobs.

So, the scheduling approach must prioritize jobs with earlier due dates.

Earliest Due Date first (EDD) 

Rule: Always schedule the job with the earliest due date next.

Effect: Jobs with the closest deadlines finish first.

Minimizes maximum lateness across all jobs.

Example:

Job   Processing Time   Due Date
J1               4                        10
J2               2                         8
J3               3                        12

Schedule using EDD: J2 → J1 → J3

Completion times:

J2: 2 → L2 = 2−8 = -6 (early, no lateness)

J1: 6 → L1 = 6−10 = -4

J3: 9 → L3 = 9−12 = -3

Maximum lateness minimized.

Key point: EDD does not necessarily minimize waiting time, but it guarantees minimized maximum lateness.

Answer: a) 

Processor Affinity:

Processor affinity (also called CPU affinity) is a scheduling concept in multiprocessor systems.

It defines the preference of a process to run on a specific CPU/core.

Purpose: improve cache performance and reduce overhead from moving processes between CPUs.

Types of Processor Affinity
1. Strong affinity→ The process must run on a specific CPU.

Example: Process P is pinned to CPU 0.

Advantage: CPU cache is reused → fewer cache misses → better performance.

Disadvantage: May reduce load balancing if that CPU becomes busy.

2. Weak affinity→ The process prefers a CPU but can run elsewhere if needed.

Balances cache performance and CPU utilization.

Answer: a) 

Critical Section Problem:

In concurrent programming, multiple processes may share resources (like variables, files, or devices).

Critical Section (CS): The part of the program where the process accesses shared resources.

Problem: If two or more processes execute their critical sections simultaneously, it can lead to race conditions and inconsistent results.

Example: Two processes incrementing the same counter. If executed simultaneously, updates may be lost.

Requirements for Solving the Critical Section Problem:

Any solution must satisfy three conditions:

Mutual Exclusion →Only one process can be in the critical section at a time.

Progress → If no process is in CS, one of the waiting processes must eventually enter.

Bounded Waiting (No Starvation) →Each process must get a chance to enter CS after waiting for some bounded time.

Answer: b)
Semaphore:
A semaphore is a synchronization tool used in operating systems for:

Mutual exclusion – to prevent multiple processes from accessing a shared resource simultaneously.
Process synchronization – to coordinate the sequence of execution among processes.

Semaphore = integer variable used for signaling.
P (wait): decrement, if <0 → process waits.
V (signal): increment; wake up waiting process if any.
Solves critical section problem, prevents race conditions.
Binary semaphore → mutual exclusion.
Counting semaphore → manages multiple identical resources.

 Answer: a) Light weight process

Why is a thread called a "lightweight process"?

Process:

→ A process is a heavy unit because it has:

→ its own memory space (code, data, heap, stack)

→ its own resources (file descriptors, registers, etc.)

→ creation and switching between processes require more overhead

A thread:

→ Exists within a process

→ Shares code, data, and files with other threads of the same process

→ Needs only a separate program counter, registers, and stack

→ Switching between threads of the same process is faster than switching between processes

Answer: b) Faster than between processes.
• Threads share resources → only registers/PC need switching.
• Processes need full memory + resources switch → heavier.

Answer: a) Increased throughput 
Multithreading:
Thread = smallest unit of CPU execution.
Multithreading = A process having multiple threads that run concurrently.
All threads share the process’s code, data, and open files, but have their own registers, PC, and stack.

Analogy:

Process = "factory"
Threads = "workers inside the factory"
Multithreading= Workers share the same tools/resources but work independently.

Advantages of Multithreading
1. Responsiveness – UI stays active (e.g., Word processor typing + spell check).
2. Resource Sharing – Threads share memory → efficient communication.
3. Economy – Thread creation/switching < Process creation/switching.

Scalability – On multi-core CPUs, multiple threads can run in parallel

a) Correct: Multithreading keeps CPU busy → more tasks completed.
b) Wrong: Multithreading increases concurrency.
c) Wrong: Deadlock is still possible.
d) Wrong: Context switching can be reduced with efficient scheduling.

Answer: c) Deadlock
If threads compete for shared resources with circular waits, deadlock occurs.

Answer: d) Formatting 
    Threads have states: New → Ready → Running → Waiting → Terminated.


  d)  "Formatting" is unrelated.

Answer: b) Preemptive Round Robin
Explanation:
Why Round Robin for threads?

→ Threads are usually lightweight units inside a process.
→ Multiple threads may belong to the same process, and they need fair CPU sharing.
→ Round Robin gives each thread a time quantum (time slice).
→ After its quantum expires → CPU switches to next thread.

This ensures:

Fairness → every thread gets CPU.

Responsiveness → especially good for interactive and I/O-bound threads.

Preemption → if one thread hogs CPU, OS can interrupt it and give others a chance.

Why not the others?

a) FCFS (First Come First Serve) → Non-preemptive.
If one thread runs a long CPU burst → all other threads wait → bad responsiveness.

Suitable for batch jobs, not threads.

c) Random → Random scheduling is unfair and unpredictable. Can cause starvation.
d) LIFO (Last In First Out) → New threads always scheduled first → older threads may starve.

Answer: d) Circular 
•    Deadlock arises if there is a circular chain of processes where each process is waiting for a resource held by the next process in the chain.
•    Example: P1 waits for R1 (held by P2), P2 waits for R2 (held by P3), … Pn waits for Rn (held by P1).

Answer: a) Deadlock prevention 
    Prevention: structurally deny one of the four Coffman’s conditions (e.g., disallow hold & wait).
    Avoidance: dynamic resource allocation (Banker’s algorithm).
    Detection: allow deadlock, then check periodically.
    Recovery: terminate processes or preempt resources to fix deadlock.

Answer: b) Deadlock avoidance 

Deadlock Avoidance means:

System analyzes each resource request before granting.
Ensures system remains in a safe state (at least one safe execution order exists).

Banker’s Algorithm is the most famous algorithm for this.

• Banker’s algorithm checks if granting a request will leave the system in a safe state.
• If yes → allocate resource.
• If no → make process wait (avoiding unsafe → deadlock states).
Analogy: Like a banker lending money only if he’s sure all loans can eventually be repaid.

Answer: b) Deadlock involves circular waiting, starvation involves indefinite waiting 
•    Deadlock → circular dependency; none can proceed.
•    Starvation → one process waits indefinitely (e.g., low-priority never scheduled).

Answer: b) At least one safe sequence of processes exists 
•    Safe sequence = an order in which all processes can finish without deadlock.
•    If such sequence exists → safe state.

Answer: a) Logical to physical address mapping.
• Paging divides logical memory into pages (fixed-size) and physical memory into frames (same size).
• The OS maintains a page table for mapping.
• It solves external fragmentation but causes internal fragmentation.

Answer: b) Segments are variable-size, pages fixed-size 
•    Paging → fixed-size chunks.
•    Segmentation → variable-size logical divisions (e.g., code, stack, data).

Answer: b) Segment number + Offset 
In Segmentation, memory is divided into logical segments such as:

Code segment
Data segment
Stack segment
Heap segment

Each logical address generated by the CPU is expressed as:
Logical Address= (Segment Number, Offset)
Segment Number → Index into the segment table.
Offset → Distance (displacement) from the start of that segment.

Answer: d) Processes spend more time swapping pages than executing 
• Thrashing → excessive paging activity → CPU utilization drops.
• Usually caused by too much degree of multiprogramming.

 Answer: b) Physical memory management, Logical memory management 
Segmentation vs Paging:
Paging cares about dividing memory into physical frames.
Segmentation divides programs into logical parts.

Answer: d) Fraction of memory accesses that cause page faults 

Formula:  P = Page Faults / Memory References    0 ≤ p ≤ 1

Answer: b) Reducing number of frames per process 

Fewer frames → higher chance needed page is not in memory → higher page fault rate p.

Answer: a) CPU utilization drops 
Thrashing:
Thrashing occurs in a computer system when processes spend more time swapping pages in and out of memory than executing actual instructions.
In other words: CPU utilization ↓ while paging activity ↑ dramatically

Cause:

Occurs in virtual memory systems when:

Too many processes are loaded into memory (high degree of multiprogramming).

Each process doesn’t have enough frames to hold its working set (the set of pages it frequently uses).

Symptoms:

Very high page fault rate.

CPU is mostly idle or underutilized, waiting for memory.

System slows down drastically, even though it seems busy.

Processes constantly swap → little useful work done → Low CPU utilization

Answer: b) Stores file metadata 

Explanation:

FCB contains:

→ File name, type, size
→ Disk block addresses
→ Creation/modification time
→ Access permissions

Answer: d) All of the above
File access methods define how a program retrieves data from a file. There are several methods depending on the organization of the file and the access requirements.

Answer: c) External fragmentation 

Explanation:
Contiguous Allocation:
In contiguous allocation, each file is stored in a set of contiguous (consecutive) blocks on the disk.
The starting block and length are recorded in the File Control Block (FCB) or directory entry.

Example:

Disk blocks: 0–19
File A → needs 5 blocks → stored at blocks 0–4
File B → needs 3 blocks → stored at blocks 5–7
File C → needs 4 blocks → stored at blocks 8–11

Why External Fragmentation Occurs:
Over time, as files are created and deleted, free blocks become scattered.
Suppose File B is deleted → free blocks 5–7
New file D requires 6 blocks → cannot be allocated contiguously even though total free space = 6 blocks exists.
This unusable scattered space = external fragmentation.
Key: Contiguous allocation cannot use free space unless it’s all together.

Answer: b) Organize files hierarchically

Explanation:

Supports directories & subdirectories → easy navigation and access.