✏ Detailed Operating System Answers

1. List any two differences between time-sharing and real-time operating

systems.

Answer:

Basis Time-Sharing Operating System Real-Time Operating System

Allows multiple users to share system Executes critical tasks within strict
Purpose
resources simultaneously. timing constraints.
Response Very quick; no delays are
Moderate; slight delays are acceptable.
Time tolerated.
Example UNIX, Windows Server VxWorks, RTLinux

🔹 Explanation:

• A Time-Sharing OS divides CPU time among users/programs to provide a

responsive multi-user environment.
• A Real-Time OS ensures immediate processing for real-world events (like airbag
deployment or industrial controls).

2. Compare batch and multitasking operating systems.

Answer:

Basis Batch Operating System Multitasking Operating System

Multiple programs run
Jobs are collected in batches and
Working simultaneously by sharing CPU
processed with no user interaction.
time.
User User can interact with multiple
No interaction during execution.
Interaction applications at once.
Example Early IBM Mainframes Windows, macOS, Linux
Time Highly efficient; improves
Less efficient; longer turnaround time.
Management responsiveness.

🔹 Explanation:

• Batch OS was suited for environments where users submitted jobs and waited for
results.
 • Multitasking OS allows running tasks like browsing the web while listening to
music.

3. Name various system components of an operating system.

Answer:

The main components of an Operating System are:

• Process Management: Handles process creation, scheduling, and termination.

• Memory Management: Allocates and tracks memory space for processes.
• File System Management: Manages files on storage devices, including directories
and permissions.
• Device Management: Manages device communication via drivers (printers,
keyboards, etc.).
• Security and Protection: Protects resources and information from unauthorized
access.
• User Interface: CLI (Command Line Interface) and GUI (Graphical User Interface)
for user communication.

🔹 Example:
In Linux, ps command shows process management, while /etc/fstab relates to file system
management.

4. Compare the advantages and disadvantages of different operating system

architectures (Monolithic, Microkernel, Hybrid).

Answer:

Architecture Advantages Disadvantages

Monolithic Faster execution, fewer context Difficult to debug, harder to
Kernel switches. maintain.
Better security and modularity. Each More communication overhead,
Microkernel
service runs separately. slower than monolithic.
Combines speed of monolithic and Can become bulky and complex if
Hybrid Kernel
modularity of microkernel. not designed properly.

🔹 Examples:

• Monolithic: Traditional Linux kernel.

• Microkernel: MINIX, QNX.
• Hybrid: Windows NT, macOS X.
5. Name two types of user interfaces provided by operating systems.

Answer:

The two primary types of User Interfaces are:

1. Command-Line Interface (CLI):

o Users interact with the OS by typing commands.
o Example: Bash Shell in Linux, Windows Command Prompt.
2. Graphical User Interface (GUI):
o Users interact with the OS through visual icons and buttons.
o Example: Windows Desktop, macOS Finder.

🔹 Explanation:

• CLI offers more control and flexibility for experienced users.

• GUI is more intuitive and user-friendly for general users.

6. Differentiate between multitasking and multiprocessing as provided by the

operating system.

Answer:

Basis Multitasking Multiprocessing

Single CPU handles multiple tasks Multiple CPUs (processors) execute
Definition
at the same time. multiple processes simultaneously.
One CPU switches tasks quickly More than one CPU handles tasks in
CPU
(time-sharing). parallel.
Speed Depends on task-switching speed. Higher performance due to true parallelism.
Windows OS running multiple apps Server systems with multiple processors
Example
on a single-core CPU. running distributed tasks.

🔹 Explanation:

• Multitasking simulates parallel execution by switching CPU time among tasks very
fast.
• Multiprocessing genuinely executes multiple processes at the same time using
multiple CPUs.

7. Define device management in an operating system. List two related

functions.

Answer:
Device Management is the part of the OS responsible for controlling all hardware devices.

🔹 Functions include:

1. Device Communication Management:

➔ Facilitates communication between the device and the operating system using
device drivers.
2. Resource Allocation:
➔ Allocates device access to different processes and manages their usage to prevent
conflicts.

🔹 Explanation:
For example, when printing a document, the OS manages the printer's queue and ensures
orderly access.

8. Apply the concept of process management to explain how an OS switches

between multiple running programs.

Answer:

• Process Management involves handling multiple active processes and ensuring fair
CPU access.
• Context Switching is the key mechanism:
➔ The OS saves the current process's state (like CPU registers, memory pointers) into
a Process Control Block (PCB).
➔ It then loads the state of the next process to resume its execution.
• Schedulers (short-term, medium-term, long-term) decide which process to run next.

🔹 Example:
When you switch from writing an email to browsing the internet, the OS quickly saves the
email app's state and loads the browser's state.

9. Assess the importance of memory management in real-time operating

systems. Justify your views with suitable scenarios.

Answer:

• Memory Management ensures that memory is allocated and accessed predictably

and efficiently.
• In Real-Time OS (RTOS):
o Fast, deterministic memory allocation is critical.
o Memory must be allocated without delays or fragmentation.
• Importance:
 o Guarantees timely execution of critical tasks (like in aerospace or medical
devices).
o Prevents unpredictable crashes or performance drops.

🔹 Scenario:
In a heart-rate monitoring system, memory must be allocated instantly to process incoming
heart signals. Any delay might cause life-threatening outcomes.

10. Define context switching, and why is it important in process management?

Answer:

Context Switching is the process where the CPU switches from one process or thread to
another.

🔹 Steps:

1. Save the state (context) of the currently running process.

2. Load the saved state of the next scheduled process.

🔹 Importance:

• Enables multitasking.
• Ensures that all processes get a fair share of CPU time.
• Essential for responsiveness in time-sharing systems.

🔹 Example:
When you minimize a video call app and open a web browser, context switching enables the
system to pause one app and resume another seamlessly.

Absolutely! Let's continue with detailed answers for Questions 11 to 20, formatted for
university-level responses:

11. List and explain the different states of a process in an operating system.

Answer:

A process in an operating system can exist in several states during its lifecycle:

1. New: The process is being created.

2. Ready: The process is prepared to run and is waiting for CPU allocation.
3. Running: The process is currently being executed by the CPU.
 4. Waiting (Blocked): The process is waiting for some event to occur (e.g., I/O
completion).
5. Terminated: The process has finished execution.

State Transitions:

• New → Ready: After creation, the process moves to the ready state.
• Ready → Running: The scheduler selects the process for execution.
• Running → Waiting: The process requires an I/O operation.
• Waiting → Ready: The I/O operation is complete.
• Running → Ready: The process is preempted to allow another process to run.
• Running → Terminated: The process completes execution.

Understanding these states helps in managing processes efficiently and ensuring optimal CPU
utilization.

12. Explain the concept of process scheduling and its importance in operating
systems.

Answer:

Process Scheduling is the mechanism by which an operating system decides the order in
which processes access the CPU. It ensures that all processes get a fair share of CPU time and
system resources.

Importance:

• Efficient CPU Utilization: Ensures the CPU is always working on a task.

• Fairness: Prevents starvation by giving each process a chance to execute.
• Responsiveness: Improves system response time, especially in interactive systems.
• Throughput Maximization: Increases the number of processes completed in a given
time.

Types of Schedulers:

• Long-term Scheduler: Decides which processes are admitted to the system for
processing.
• Short-term Scheduler: Decides which of the ready, in-memory processes is to be
executed next.
• Medium-term Scheduler: Swaps processes in and out of memory to manage the
degree of multiprogramming.

Effective scheduling enhances system performance and user satisfaction.

13. Describe the First-Come, First-Served (FCFS) scheduling algorithm with
an example.

Answer:

FCFS is the simplest scheduling algorithm where the process that arrives first gets executed
first.

Characteristics:

• Non-preemptive: Once a process starts execution, it runs to completion.

• Fairness: Processes are handled in the order of arrival.

Example:

Consider three processes with the following arrival and burst times:

Process Arrival Time Burst Time

P1 0 5
P2 1 3
P3 2 8

Execution Order: P1 → P2 → P3

Waiting Times:

• P1: 0
• P2: 5 - 1 = 4
• P3: (5 + 3) - 2 = 6

Average Waiting Time: (0 + 4 + 6) / 3 = 3.33 units

While FCFS is simple, it can lead to the "convoy effect," where short processes wait for long
ones to finish.

14. What is the Shortest Job First (SJF) scheduling algorithm? Discuss its
advantages and disadvantages.

Answer:

SJF selects the process with the smallest execution time for the next execution.

Advantages:

• Optimal Average Waiting Time: Minimizes the average waiting time compared to
other algorithms.
Disadvantages:

• Requires Knowledge of Burst Time: Not always possible to know in advance.

• Starvation: Longer processes may be indefinitely postponed if short processes keep
arriving.

Example:

Processes with burst times:

Process Burst Time

P1 6
P2 8
P3 7
P4 3

Execution Order: P4 → P1 → P3 → P2

SJF is efficient but impractical in environments where process lengths are unpredictable.

15. Explain the Round Robin (RR) scheduling algorithm and its suitability for
time-sharing systems.

Answer:

Round Robin assigns a fixed time quantum to each process in the ready queue and cycles
through them.

Characteristics:

• Preemptive: Processes are interrupted after their time quantum expires.

• Fairness: Each process gets equal CPU time slices.

Example:

Processes with burst times:

Process Burst Time

P1 10
P2 4
P3 5

With a time quantum of 3 units, the execution order would cycle through the processes,
allocating 3 units each time until completion.
Suitability:

Ideal for time-sharing systems where responsiveness is crucial, as it ensures all processes are
served in a timely manner.

16. Define deadlock in operating systems and explain the necessary conditions
for its occurrence.

Answer:

A deadlock is a situation where a set of processes are blocked because each process is
holding a resource and waiting for another resource acquired by some other process.

Necessary Conditions (Coffman Conditions):

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

2. Hold and Wait: A process is holding at least one resource and waiting to acquire
additional resources held by other processes.
3. No Preemption: Resources cannot be forcibly removed from the processes holding
them.
4. Circular Wait: A set of processes are waiting for each other in a circular chain.

All these conditions must hold simultaneously for a deadlock to occur.

17. Differentiate between deadlock prevention and deadlock avoidance

strategies.

Answer:

Aspect Deadlock Prevention Deadlock Avoidance

Proactively negate one of the Dynamically examine resource
Approach
Coffman conditions allocation to ensure safe state
Resource
Conservative Flexible, based on current state
Allocation
Simpler but may lead to resource Complex, requires additional
Implementation
underutilization information
Example Disallow hold and wait Banker's Algorithm

Deadlock Prevention eliminates the possibility of deadlock by structurally negating one of

the necessary conditions.

Deadlock Avoidance allows the system to enter into a state only if it doesn't lead to a
deadlock.
18. What is the Banker's Algorithm? How does it help in deadlock avoidance?

Answer:

The Banker's Algorithm is a deadlock avoidance algorithm that tests for the safety of
resource allocation by simulating the allocation for predetermined maximum possible
amounts of all resources.

Working:

• Each process must declare the maximum number of resources it may need.
• The system checks if allocating resources to a process leads to a safe state.
• If yes, resources are allocated; otherwise, the process waits.

Example:

If a process requests resources, the system checks if the remaining resources are sufficient for
the other processes. If not, the request is denied to avoid potential deadlock.

This algorithm ensures that the system always remains in a safe state, thus avoiding
deadlocks.

19. Explain the concept of memory management in operating systems and its
objectives.

Answer:

Memory Management is the function of an operating system that handles or manages

primary memory and moves processes back and forth between main memory and disk during
execution.

Objectives:

• Efficient Memory Utilization: Maximize the use of available memory.

• Process Isolation: Ensure that one process doesn't interfere with another's memory.
• Dynamic Allocation: Allocate and deallocate memory as needed.
• Support for Multiprogramming: Allow multiple processes to reside in memory
simultaneously.

Effective memory management is crucial for system stability and performance.

20. Differentiate between contiguous and non-contiguous memory allocation

techniques.
Answer:

Aspect Contiguous Allocation Non-Contiguous Allocation

Assigns a single contiguous Allocates memory in multiple blocks
Memory Allocation
block of memory scattered throughout memory
Less flexible, can lead to
Flexibility More flexible, reduces fragmentation
fragmentation
Implementation More complex due to tracking multiple
Simpler
Complexity blocks
Single Partition, Multiple
Examples Paging, Segmentation
Partition schemes

Contiguous Allocation is straightforward but can suffer from fragmentation.

Non-Contiguous Allocation allows processes to occupy non-adjacent memory segments,

improving memory utilization.

21. Layered Architecture of an Operating System

The layered architecture of an operating system is a design approach that divides the OS into
different layers, each of which handles specific tasks. This structure improves modularity,
maintainability, and understandability. The layers are typically stacked, where each layer
communicates only with the adjacent layers. The layers are usually defined as follows:

1. Layer 0: Hardware
The base of the OS is the hardware layer, which consists of the physical components
of the computer system, such as the CPU, memory, and I/O devices. The OS has
direct control over hardware resources through device drivers.
2. Layer 1: Kernel
The kernel layer is the core part of the OS responsible for low-level tasks such as
memory management, process management, device management, and system calls. It
provides an interface between the hardware and the software, ensuring safe and
efficient execution of processes.
3. Layer 2: System Call Interface
This layer acts as an intermediary between user applications and the kernel. It
provides an interface for user programs to make requests to the OS kernel, typically
via system calls (e.g., file operations, process creation).
4. Layer 3: User Interface
The user interface layer includes components like the shell, graphical user interface
(GUI), or command-line interface (CLI). It allows users to interact with the operating
system and run applications.
5. Layer 4: Application Software
The top layer consists of application programs that run on the operating system, such
as word processors, browsers, and games. These programs interact with the OS
through the system call interface.

Advantages of Layered Architecture:

 • Modularity: Each layer is independent, which makes it easier to develop and
maintain the system.
• Ease of Debugging: Problems are easier to isolate and debug due to clear separation
of concerns between layers.
• Portability: Higher layers are less dependent on specific hardware, making it easier
to port the OS to different hardware.

Disadvantages of Layered Architecture:

• Performance Overhead: Communication between layers can introduce overhead due

to the need for additional context switching and interface calls.
• Complexity in Design: Designing a well-structured layered system requires careful
planning to ensure that layers interact efficiently.

22. Concept of Threads and Their Management in Modern Operating Systems

A thread is the smallest unit of execution within a process. A thread consists of a set of
instructions that can be executed independently, but it shares the same memory space as other
threads within the same process.

Types of Threads:

1. User-Level Threads: Managed by user-level libraries rather than the OS. The OS
kernel does not know about these threads, making management lightweight.
2. Kernel-Level Threads: Managed directly by the OS. The kernel is responsible for
scheduling and managing these threads, and each thread is treated as a separate entity
by the operating system.

Thread Management: Thread management involves tasks such as creation, scheduling,

synchronization, and termination. Modern operating systems use the following techniques to
manage threads:

• Thread Creation: When a new thread is created, the OS allocates resources such as
stack memory and thread control blocks (TCB) to manage the thread's execution.
• Scheduling: The operating system schedules threads for execution based on their
priority and state. Scheduling algorithms such as Round-Robin, Shortest Job First,
and Priority Scheduling are often used.
• Synchronization: To ensure correct access to shared resources, threads often need to
synchronize. Common synchronization techniques include locks, semaphores, and
monitors.
• Termination: A thread is terminated when it finishes its execution or is forcibly
terminated by the OS due to an error or other condition.

Advantages of Threads:

• Parallelism: Multiple threads can run concurrently on multiple processors, improving

system performance.
 • Resource Sharing: Threads within the same process share memory, making
communication between them faster than between separate processes.

Disadvantages of Threads:

• Complexity in Synchronization: Threads must be carefully synchronized to avoid

issues like race conditions, deadlocks, or data corruption.
• Overhead: Creating and managing threads introduces overhead, and excessive
threads may lead to inefficiencies.

23. Advantages and Disadvantages of a Layered Operating System Structure

Advantages:

1. Modularity: Each layer is independent, making it easier to manage and update

specific parts of the OS without affecting the entire system.
2. Separation of Concerns: By dividing responsibilities among layers, each layer
focuses on specific functions, leading to simpler design and maintenance.
3. Maintainability: Bugs and issues can be isolated to specific layers, facilitating easier
debugging and faster problem resolution.
4. Portability: The OS can be more easily adapted to new hardware as the higher layers
are abstracted from the hardware-specific details.

Disadvantages:

1. Performance Overhead: Communication between layers can cause additional

overhead due to the extra layers of abstraction and context-switching between layers.
2. Complexity in Design: Designing a layered system requires careful thought to ensure
that the division of responsibilities makes sense and does not lead to inefficiencies.
3. Limited Flexibility: Some layers may become bottlenecks, making it harder to
modify or replace specific components without affecting the entire system.

24. Primary Function of a Scheduler in an Operating System

A scheduler is a core component of an operating system that determines the order in which
processes or threads are executed. It is responsible for allocating CPU time to different
processes, ensuring that system resources are utilized efficiently.

Types of Schedulers:

1. Long-Term Scheduler: Determines which processes are admitted into the system
(i.e., moved from the job pool to the ready queue).
2. Short-Term Scheduler: Decides which of the ready processes will be executed next
by the CPU.
3. Medium-Term Scheduler: Involved in swapping processes in and out of memory to
balance the load.
Key Functions of a Scheduler:

• Fair Allocation of CPU Time: The scheduler ensures that no process monopolizes
the CPU and that all processes get a fair share of CPU time.
• Prioritization: The scheduler may prioritize certain processes based on factors like
priority, real-time constraints, or user preferences.
• Context Switching: The scheduler manages the state of the CPU when switching
between processes, ensuring that the system continues execution without loss of data.

25. How the Medium-Term Scheduler Helps in Improving System

Performance Through Swapping

The medium-term scheduler helps improve system performance by managing the swapping
of processes in and out of the main memory. This technique, known as swapping, allows the
operating system to handle more processes than the physical memory can accommodate at
once, thus preventing the system from being overwhelmed.

Role of Medium-Term Scheduler:

1. Process Swapping: The medium-term scheduler selects processes that are in the
ready queue but not currently being executed. These processes are swapped out of the
main memory to disk to free up space for other processes.
2. Balancing Memory Usage: By swapping processes in and out, the medium-term
scheduler ensures that the most active processes are kept in memory while less active
processes are temporarily moved to disk storage.
3. Improved Throughput: Swapping enables the system to run more processes
simultaneously, leading to better CPU utilization and higher system throughput.
4. Avoiding Deadlock and Resource Contention: Swapping can alleviate resource
contention by ensuring that the memory is not overwhelmed by too many processes
competing for space.

Benefits of Swapping:

• Improved Resource Utilization: By keeping the CPU busy with processes that fit in
memory, overall system throughput can be improved.
• Efficient Memory Management: Swapping allows the operating system to maximize
memory usage and maintain system responsiveness.

Challenges:

• Performance Overhead: Swapping in and out of processes introduces latency, as

moving processes between memory and disk is time-consuming.
• Disk I/O: Heavy swapping may lead to excessive disk I/O, which can degrade
performance, particularly when the system has insufficient swap space.
26. Why is the Long-Term Scheduler Also Known as the Job Scheduler, and
What Impact Does It Have on System Load?

The long-term scheduler is also known as the job scheduler because its primary
responsibility is to control the admission of jobs (or processes) into the ready queue. It
determines which processes should be brought into memory for execution. The job scheduler
selects processes from the job pool based on various factors such as priority, system load, and
resource availability.

Impact on System Load:

• The long-term scheduler has a direct impact on the system's load because it controls
the number of processes in memory at any given time.
• By admitting or rejecting jobs, the long-term scheduler ensures that the system doesn't
become overloaded with too many processes. This helps maintain optimal system
performance by controlling the degree of multiprogramming (how many processes
are active in memory).
• If too many processes are admitted, the system might become overloaded, leading to
excessive paging or swapping, which will slow down the system. On the other hand,
if too few processes are admitted, the system may not fully utilize its CPU, leading to
underutilization.

27. Compare and Contrast Long-Term Scheduling and Short-Term

Scheduling in Terms of Their Frequency and Impact on System Performance

Long-Term Scheduling (Job Scheduling):

• Frequency: Runs much less frequently compared to the short-term scheduler. It

decides which jobs to admit into the system or the ready queue.
• Impact on System Performance:
o It impacts the degree of multiprogramming and helps maintain a balanced
load by admitting the appropriate number of processes.
o A high degree of multiprogramming can increase CPU utilization but might
lead to swapping if the memory is overwhelmed.
o It does not directly affect the responsiveness of the system but influences long-
term resource utilization.

Short-Term Scheduling (CPU Scheduling):

• Frequency: Runs much more frequently, typically every time a process is swapped
out or completed. It determines which process gets the CPU next.
• Impact on System Performance:
o It has a direct impact on system responsiveness and efficiency by
determining the CPU's execution sequence.
o Effective short-term scheduling algorithms can ensure fairness and
maximized CPU utilization while minimizing response times.
 o Poor short-term scheduling can lead to inefficient CPU usage, poor process
turnaround, or starvation for some processes.

28. Define Pre-emptive CPU Scheduling and Give Any Two Examples

Pre-emptive CPU Scheduling is a type of CPU scheduling where the operating system can
interrupt (or preempt) a running process to allocate CPU time to another process. This
ensures that high-priority tasks get immediate CPU access, preventing lower-priority tasks
from monopolizing the CPU.

Examples:

1. Round Robin (RR): The scheduler assigns a fixed time quantum (e.g., 10ms) to each
process in the ready queue. If a process does not finish within its allocated time, it is
preempted and placed at the back of the ready queue.
2. Preemptive Priority Scheduling: In this algorithm, each process has a priority. A
running process can be preempted if a new process with a higher priority arrives,
allowing the higher-priority process to execute immediately.

29. Differentiate Between Pre-emptive and Non-pre-emptive CPU Scheduling

with an Example

Pre-emptive Scheduling:

• In pre-emptive scheduling, the operating system can interrupt the currently running
process to switch to another process.
• This allows the OS to allocate CPU resources more efficiently and respond to high-
priority tasks promptly.
• Example: Round Robin Scheduling — Each process is given a fixed time slice. If
the process doesn't complete within the slice, it is preempted, and the next process is
executed.

Non-Pre-emptive Scheduling:

• In non-pre-emptive scheduling, once a process starts execution, it runs to completion

or until it voluntarily yields the CPU (e.g., due to I/O requests).
• Example: First-Come-First-Serve (FCFS) — The first process to arrive is the first
to be executed, and it runs until completion before the next process starts.

Key Differences:

• Pre-emptive: The system can take control away from the process anytime (e.g., for
higher priority tasks).
• Non-Pre-emptive: Once a process starts, it runs to completion without interruption
(unless it voluntarily gives up control).
30. Explain How Context Switching Occurs in Pre-emptive CPU Scheduling

Context Switching occurs when the operating system's scheduler decides to stop the
execution of the current process and start the execution of another process. This process is
essential in preemptive scheduling to ensure that the CPU is allocated fairly and efficiently.

Steps of Context Switching:

1. Save the Context of the Current Process: The state of the currently running process,
including its CPU registers, program counter, and other relevant information, is saved
into its process control block (PCB).
2. Select the Next Process: The scheduler selects the next process to execute from the
ready queue.
3. Load the Context of the New Process: The state of the new process, saved in its
PCB, is loaded into the CPU registers.
4. Update Process State: The current process's state is updated to "Ready," and the new
process’s state is updated to "Running."
5. Transfer Control: Control is passed to the new process, and it begins execution.

Context switching is an overhead operation, and excessive context switching can reduce
system performance by consuming CPU cycles without performing useful computation.

31. Shortest Job First (SJF) Scheduling with Average Turnaround Time
Calculation

Given:

• Arrival Time: P1 (0ms), P2 (2ms), P3 (4ms), P4 (5ms)

• Burst Time: P1 (7ms), P2 (4ms), P3 (1ms), P4 (4ms)

SJF Scheduling (non-preemptive) works by selecting the process with the shortest burst time
next.
Gantt Chart (execution order):
P1 -> P2 -> P4 -> P3

Turnaround Time: The turnaround time for a process is the total time from its arrival to its
completion, including waiting time.

Turnaround Time for Each Process:

• P1: Completion time = 7ms (turnaround time = 7 - 0 = 7ms)

• P2: Completion time = 7ms + 4ms = 11ms (turnaround time = 11 - 2 = 9ms)
• P3: Completion time = 11ms + 1ms = 12ms (turnaround time = 12 - 4 = 8ms)
• P4: Completion time = 12ms + 4ms = 16ms (turnaround time = 16 - 5 = 11ms)

Average Turnaround Time = (7 + 9 + 8 + 11) / 4 = 8.75ms

32. Priority Scheduling with Average Waiting Time Calculation

Given:

• Process Arrival Time: P1 (0ms), P2 (1ms), P3 (2ms), P4 (3ms)

• Priority: P1 (3), P2 (1), P3 (2), P4 (4)
• Burst Time: P1 (6ms), P2 (8ms), P3 (7ms), P4 (3ms)

Priority Scheduling (non-preemptive) schedules based on priority values (lower value =

higher priority).

Gantt Chart (execution order):

P2 -> P3 -> P1 -> P4

Waiting Time for Each Process:

• P1: Waiting time = (start time of P1 - arrival time of P1) = 14ms - 0ms = 14ms
• P2: Waiting time = 0ms
• P3: Waiting time = 14ms - 2ms = 12ms
• P4: Waiting time = 14ms - 3ms = 11ms

Average Waiting Time = (14 + 0 + 12 + 11) / 4 = 9.25ms

33. Pre-emptive Round Robin Scheduling with Time Quantum of 3ms

Given:

• Process Arrival Time: P1 (0ms), P2 (2ms), P3 (4ms), P4 (5ms)

• Burst Time: P1 (7ms), P2 (4ms), P3 (1ms), P4 (4ms)
• Time Quantum: 3ms

Gantt Chart: P1 -> P2 -> P3 -> P4 -> P1 -> P2 -> P4 -> P1

Turnaround Time Calculation: Turnaround time = Completion time - Arrival time

34. Shortest Remaining Time First (SRTF) Scheduling

Given:

• Process Arrival Time: P1 (0ms), P2 (1ms), P3 (2ms)

• Burst Time: P1 (2ms), P2 (4ms), P3 (8ms)

Gantt Chart and Average Waiting Time: Follow the SRTF scheduling rules to compute
these metrics.
35. Preemptive Priority Scheduling - Gantt Chart, Average Waiting Time,
and Turnaround Time

Given:

• Process Arrival Time | Burst Time | Priority (Lower is higher priority)

o P1: Arrival = 0ms, Burst = 7ms, Priority = 6
o P2: Arrival = 1ms, Burst = 9ms, Priority = 8
o P3: Arrival = 3ms, Burst = 11ms, Priority = 7
o P4: Arrival = 4ms, Burst = 10ms, Priority = 5 (Lowest Priority)
o P5: Arrival = 6ms, Burst = 8ms, Priority = 9
o P6: Arrival = 11ms, Burst = 4ms, Priority = 10 (Highest Priority)

Preemptive Priority Scheduling Explanation:

• Preemptive Priority Scheduling assigns the CPU to the process with the highest
priority (the smallest priority number).
• If a new process arrives with a higher priority than the currently running process, the
running process is preempted, and the new process is assigned the CPU.

Gantt Chart Construction:

To create the Gantt chart, we simulate the scheduling process with the arrival times, burst
times, and priorities:

1. P1 starts at time 0ms (since it’s the only process available). But at time 1ms, P2
arrives with a lower priority (higher priority number) than P1 (P2 has priority 8, P1
has priority 6), so P1 continues its execution.
2. P3 arrives at time 3ms with priority 7, and since P1 (priority 6) has a higher priority,
it continues.
3. At time 4ms, P4 arrives with priority 5 (higher than P1 and P3), so it preempts P1.
 4. After P4 executes for 4ms, the CPU goes back to P1 and the process continues.

Gantt Chart:
Time: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
17 18 19 20
Process: P1 P1 P1 P1 P4 P4 P4 P1 P2 P2 P2 P3 P3 P3 P3 P5 P5
P6 P6 P6

• P1 runs from time 0 to 4ms (4ms), then is preempted by P4.

• P4 runs from time 4 to 7ms (3ms).
• P1 resumes from time 7 to 10ms (3ms).
• P2 arrives at 1ms and runs from time 10 to 14ms (4ms).
• P3 runs after P2 from time 14 to 18ms (4ms).
• P5 runs from time 18 to 22ms (4ms).
• P6 runs from time 22 to 25ms (4ms).

Waiting Time Calculation:

The waiting time for each process is calculated as:

Waiting Time=Turnaround Time−Burst Time\text{Waiting Time} = \text{Turnaround Time}

- \text{Burst Time}

Where Turnaround Time = Completion Time - Arrival Time.

Waiting Times:

• P1: Completion Time = 10ms, Arrival Time = 0ms

Waiting Time for P1=10−0−7=3ms\text{Waiting Time for P1} = 10 - 0 - 7 = 3
\text{ms}
• P2: Completion Time = 14ms, Arrival Time = 1ms
Waiting Time for P2=14−1−9=4ms\text{Waiting Time for P2} = 14 - 1 - 9 = 4
\text{ms}
• P3: Completion Time = 18ms, Arrival Time = 3ms
Waiting Time for P3=18−3−11=4ms\text{Waiting Time for P3} = 18 - 3 - 11 = 4
\text{ms}
• P4: Completion Time = 7ms, Arrival Time = 4ms
Waiting Time for P4=7−4−10=−7ms\text{Waiting Time for P4} = 7 - 4 - 10 = -7
\text{ms}
• P5: Completion Time = 22ms, Arrival Time = 6ms
Waiting Time for P5=22−6−8=8ms\text{Waiting Time for P5} = 22 - 6 - 8 = 8
\text{ms}
• P6: Completion Time = 25ms, Arrival Time = 11ms
Waiting Time for P6=25−11−4=10ms\text{Waiting Time for P6} = 25 - 11 - 4 = 10
\text{ms}

Average Waiting Time:

Average Waiting Time=(3+4+4+0+8+10)6=296=4.83ms\text{Average Waiting Time} =
\frac{(3 + 4 + 4 + 0 + 8 + 10)}{6} = \frac{29}{6} = 4.83 \text{ms}

Turnaround Time Calculation:

The turnaround time is calculated as:

Turnaround Time=Completion Time−Arrival Time\text{Turnaround Time} =

\text{Completion Time} - \text{Arrival Time}

Turnaround Times:

• P1: Completion Time = 10ms, Arrival Time = 0ms

Turnaround Time for P1=10−0=10ms\text{Turnaround Time for P1} = 10 - 0 = 10
\text{ms}
• P2: Completion Time = 14ms, Arrival Time = 1ms
Turnaround Time for P2=14−1=13ms\text{Turnaround Time for P2} = 14 - 1 = 13
\text{ms}
• P3: Completion Time = 18ms, Arrival Time = 3ms
Turnaround Time for P3=18−3=15ms\text{Turnaround Time for P3} = 18 - 3 = 15
\text{ms}
• P4: Completion Time = 7ms, Arrival Time = 4ms
Turnaround Time for P4=7−4=3ms\text{Turnaround Time for P4} = 7 - 4 = 3
\text{ms}
• P5: Completion Time = 22ms, Arrival Time = 6ms
Turnaround Time for P5=22−6=16ms\text{Turnaround Time for P5} = 22 - 6 = 16
\text{ms}
• P6: Completion Time = 25ms, Arrival Time = 11ms
Turnaround Time for P6=25−11=14ms\text{Turnaround Time for P6} = 25 - 11 = 14
\text{ms}

Average Turnaround Time:

Average Turnaround Time=(10+13+15+3+16+14)6=716=11.83ms\text{Average Turnaround

Time} = \frac{(10 + 13 + 15 + 3 + 16 + 14)}{6} = \frac{71}{6} = 11.83 \text{ms}

Summary:

• Gantt Chart:
• Time: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
15 16 17 18 19 20
• Process: P1 P1 P1 P1 P4 P4 P4 P1 P2 P2 P2 P3 P3 P3 P3
P5 P5 P6 P6 P6
• Average Waiting Time: 4.83ms
• Average Turnaround Time: 11.83ms
36. Comparison and Analysis of Round Robin (RR), Shortest Remaining Time
First (SRTF) Scheduling Algorithms

Given:

• Processes and their details:

Process Arrival Time Burst Time

P1 5ms 5ms
P2 4ms 6ms
P3 3ms 7ms
P4 1ms 9ms
P5 2ms 2ms
P6 6ms 3ms

1. Round Robin (RR) Scheduling (Time Quantum = 4 ms):

• Round Robin executes processes in a cyclic order, allocating CPU time to each
process in the ready queue for a fixed time quantum (4ms here), after which it moves
to the next process.
 • If a process's burst time is not completed within its quantum, it is preempted and
re-entered at the end of the queue. The process continues executing until its burst
time completes.

Gantt Chart for RR (Time Quantum = 4ms):

Time: 1 5 9 13 15 17 21 25 29
Process: P4 P5 P2 P1 P2 P3 P2 P3 P6

• P4 starts at time 1ms and runs for 4ms (until time 5ms).
• P5 runs next for 2ms (until time 7ms).
• P2 starts at time 7ms and runs for 4ms (until time 11ms).
• P1 runs for 4ms (until time 15ms).
• P2 continues and runs for 2ms (until time 17ms).
• P3 runs for 4ms (until time 21ms).
• P2 runs for the remaining 2ms (until time 23ms).
• P3 runs for the remaining 3ms (until time 26ms).
• P6 runs for 3ms (until time 29ms).

Average Waiting Time (AWT) Calculation for RR:

For each process, the waiting time is calculated as:

Waiting Time=Turnaround Time−Burst Time\text{Waiting Time} = \text{Turnaround Time}
- \text{Burst Time} Turnaround Time=Completion Time−Arrival Time\text{Turnaround
Time} = \text{Completion Time} - \text{Arrival Time}

• P4: Turnaround Time = 9 - 1 = 8ms, Waiting Time = 8 - 9 = -1ms

• P5: Turnaround Time = 7 - 2 = 5ms, Waiting Time = 5 - 2 = 3ms
• P2: Turnaround Time = 23 - 4 = 19ms, Waiting Time = 19 - 6 = 13ms
• P1: Turnaround Time = 15 - 5 = 10ms, Waiting Time = 10 - 5 = 5ms
• P3: Turnaround Time = 26 - 3 = 23ms, Waiting Time = 23 - 7 = 16ms
• P6: Turnaround Time = 29 - 6 = 23ms, Waiting Time = 23 - 3 = 20ms

Average Waiting Time (AWT):

(−1+3+13+5+16+20)6=566=9.33 ms\frac{(-1 + 3 + 13 + 5 + 16 + 20)}{6} = \frac{56}{6} =

9.33 \, \text{ms}

Average Turnaround Time (ATAT) for RR:

(8+5+19+10+23+23)6=886=14.67 ms\frac{(8 + 5 + 19 + 10 + 23 + 23)}{6} = \frac{88}{6} =

14.67 \, \text{ms}

Average Response Time (ART) for RR:

In RR, the response time is the time from when a process arrives until its first execution.

• P4: Response Time = 1ms

• P5: Response Time = 2ms
• P2: Response Time = 4ms
 • P1: Response Time = 5ms
• P3: Response Time = 3ms
• P6: Response Time = 6ms

Average Response Time (ART):

(1+2+4+5+3+6)6=216=3.5 ms\frac{(1 + 2 + 4 + 5 + 3 + 6)}{6} = \frac{21}{6} = 3.5 \,

\text{ms}

2. Shortest Remaining Time First (SRTF):

• SRTF is a preemptive scheduling algorithm where the process with the smallest
remaining burst time is selected next.
• A process can be preempted if another process with a shorter remaining burst time
arrives.

Gantt Chart for SRTF:

Time: 1 2 5 6 9 12 15 16 19 22 23 24
Process: P4 P5 P2 P6 P3 P1 P2 P3 P3 P6 P1

• P4 starts at time 1ms.

• P5 arrives at time 2ms, preempts P4.
• P2 arrives at time 4ms, preempts P5.
• P6 arrives at time 6ms, preempts P2.
• P3 arrives at time 3ms and gets executed.
• The processes continue to switch in such a way that the shortest burst time is always
executed next.

Average Waiting Time (AWT) for SRTF:

• P4: Turnaround Time = 9 - 1 = 8ms, Waiting Time = 8 - 9 = -1ms

• P5: Turnaround Time = 7 - 2 = 5ms, Waiting Time = 5 - 2 = 3ms
• P2: Turnaround Time = 23 - 4 = 19ms, Waiting Time = 19 - 6 = 13ms
• P1: Turnaround Time = 15 - 5 = 10ms, Waiting Time = 10 - 5 = 5ms
• P3: Turnaround Time = 26 - 3 = 23ms, Waiting Time = 23 - 7 = 16ms
• P6: Turnaround Time = 29 - 6 = 23ms, Waiting Time = 23 - 3 = 20ms

Average Waiting Time (AWT):

(−1+3+13+5+16+20)6=566=9.33 ms\frac{(-1 + 3 + 13 + 5 + 16 + 20)}{6} = \frac{56}{6} =

9.33 \, \text{ms}

Average Turnaround Time (ATAT) for SRTF:

(8+5+19+10+23+23)6=886=14.67 ms\frac{(8 + 5 + 19 + 10 + 23 + 23)}{6} = \frac{88}{6} =

14.67 \, \text{ms}

Average Response Time (ART) for SRTF:

 • P4: Response Time = 1ms
• P5: Response Time = 2ms
• P2: Response Time = 4ms
• P1: Response Time = 5ms
• P3: Response Time = 3ms
• P6: Response Time = 6ms

Average Response Time (ART):

(1+2+4+5+3+6)6=216=3.5 ms\frac{(1 + 2 + 4 + 5 + 3 + 6)}{6} = \frac{21}{6} = 3.5 \,

\text{ms}

Summary Comparison:

Round Robin Shortest Remaining Time First

Metric
(RR) (SRTF)
Average Waiting Time (AWT) 9.33 ms 9.33 ms
Average Turnaround Time
14.67 ms 14.67 ms
(ATAT)
Average Response Time (ART) 3.5 ms 3.5 ms

Conclusion:

• Round Robin and SRTF performed similarly in this case with the same AWT,
ATAT, and ART.
• SRTF can be more efficient in minimizing waiting time when processes have highly
varied burst times, but it also has the potential for high overhead due to frequent
preemptions.
• RR provides a fairer distribution of CPU time, but may result in higher turnaround
times for some processes.

37. Difference Between Concurrency and Parallel Processing

Concurrency:

Concurrency is the ability of a system to handle multiple tasks at the same time, but not
necessarily simultaneously. In a concurrent system, multiple tasks are in progress at
overlapping time intervals. However, these tasks may be executing one at a time, with the
system switching between them (multitasking), creating an illusion of simultaneous
execution.

Key points about concurrency:

1. Task Overlap: Tasks can be in progress at the same time, but only one task is
executed at any given instant.
2. Single Core/Processor: Concurrency can occur on a single-core system by rapidly
switching between tasks.
 3. Context Switching: The operating system may switch between tasks using context
switching, where the state of one task is saved and another task is resumed.
4. Independent or Dependent Tasks: Concurrency is ideal when tasks can be
independent or need to coordinate with each other (e.g., in web servers or
multitasking OS).
5. Conceptual: Concurrency is more about structure or design—how tasks are designed
to be handled concurrently, not necessarily their actual simultaneous execution.

Parallel Processing:

Parallel processing involves performing multiple tasks simultaneously by dividing them into
smaller sub-tasks that can be executed at the same time on multiple processors or cores. In
parallel processing, tasks are physically executed at the same time, which speeds up the
overall computation.

Key points about parallel processing:

1. Simultaneous Execution: Tasks or sub-tasks run in parallel on different cores or

processors.
2. Multiple Cores/Processors: Parallel processing requires a system with multiple
processors or cores capable of executing tasks simultaneously.
3. Performance Boost: Parallel processing is used to speed up computationally
intensive operations, such as scientific simulations or large-scale data analysis.
4. Task Division: A task is divided into smaller parts that can be executed concurrently
on different processors, and the results are combined afterward.
5. Real Simultaneity: In parallel processing, tasks are physically executing at the same
time.

Summary of Key Differences:

Aspect Concurrency Parallel Processing

Executing multiple tasks
Handling multiple tasks by
Definition simultaneously on multiple
switching between them.
processors.
Tasks are in progress at Tasks are executed simultaneously on
Execution
overlapping intervals. different processors or cores.
Processor Single-core processor or multi-
Multi-core or multi-processor system.
Requirement core (with time slicing).
Managing multiple tasks, Speeding up processing by executing
Goal
improving responsiveness. tasks at the same time.
Tasks are divided and executed
Context Involves switching between tasks,
simultaneously on different
Switching may not be simultaneous.
processors.
Web server handling multiple Running large simulations, matrix
Example
client requests. operations in scientific computing.
Conclusion:

Concurrency is more about structuring and handling tasks efficiently, while parallel
processing is about executing tasks simultaneously for faster performance. They can be used
together in modern systems, where concurrency handles multiple tasks at once, and parallel
processing speeds up specific computational tasks within those tasks.

38. How does OS ensure Mutual Exclusion in concurrent processes?

The Operating System ensures mutual exclusion in concurrent processes to prevent race
conditions and allow only one process to access a critical resource at a time. Mutual
exclusion is primarily ensured using synchronization mechanisms such as:

1. Locks: A lock is used to guarantee that only one process can access the critical
section at any given time. If a process locks a resource, other processes that try to lock
the same resource will be blocked until the first process releases the lock.
o Example: Mutex (Mutual Exclusion) is a lock that allows only one process to
access a resource at a time.
2. Semaphores: A semaphore is a signaling mechanism that can be used to control
access to shared resources. It maintains a count and allows processes to access the
critical section based on the semaphore value.
3. Monitors: Monitors are high-level synchronization primitives that encapsulate shared
resources and provide automatic locking mechanisms. A process must acquire a
monitor to access a resource, ensuring mutual exclusion.
4. Disabling Interrupts: In single-processor systems, the OS may disable interrupts
temporarily to prevent context switching during critical operations.

These mechanisms ensure that only one process at a time can access a critical resource,
preventing conflicts and ensuring data integrity.

39. Explain the race condition with the help of a suitable example?

A race condition occurs when the outcome of a process is dependent on the sequence or
timing of uncontrollable events (e.g., the execution order of threads or processes). It happens
when multiple processes or threads access shared data and try to change it simultaneously,
leading to unpredictable or incorrect results.

Example:

Consider two processes, P1 and P2, both incrementing a shared variable x.

1. Initially, x = 0.
2. P1 reads x (value 0) and prepares to increment it.
3. P2 reads x (value 0) and prepares to increment it.
4. P1 increments x and updates x = 1.
5. P2 increments x (which it read as 0) and updates x = 1.
Expected value of x after both processes complete should be 2, but due to the race condition,
x ends up being 1 because both processes read the value of x at the same time and did not
observe each other’s changes.

To prevent this, synchronization (e.g., using a lock or semaphore) should be applied to the
shared resource x to ensure mutual exclusion.

40. How do you define critical section in concurrent programming? Explain

with the help of suitable example and diagram.

In concurrent programming, a critical section refers to a part of the code where shared
resources are accessed or modified by multiple processes or threads. Only one process should
be allowed to execute the critical section at any time to avoid conflicts and maintain data
integrity.

Example:

Consider two processes P1 and P2, both trying to access and update a shared bank account
balance. The critical section would be the code segment where the balance is read and
updated:

balance = balance - 100; // Critical section

balance = balance + 100; // Critical section

If both processes try to update the balance simultaneously, a race condition could occur,
leading to inconsistent or incorrect results. To ensure mutual exclusion, only one process
should be allowed in the critical section at a time.

Diagram:

+-------------------------------+
| Critical Section (Critical) |
| Process P1 or P2 enters. |
+-------------------------------+
|
Mutex / Semaphore / Lock
|
+-------------------------------+
| Shared Resource Access |
+-------------------------------+

This shows that only one process can enter the critical section at a time to access or modify
the shared resource.

41. Explain the concept of Race Condition with the help of a simple example
involving two processes incrementing a shared variable.
A race condition occurs when two or more processes attempt to update a shared resource
simultaneously, causing an unpredictable result.

Example:

Consider the shared variable counter initialized to 0. Two processes, P1 and P2, are
incrementing the counter.

• P1: Read counter, increment, write back.

• P2: Read counter, increment, write back.

If both processes execute concurrently without synchronization, they might both read the
same value of counter before either process writes back its increment. This results in one
update being lost.

Execution:

1. Initially, counter = 0.
2. P1 reads counter (value 0), increments it to 1.
3. P2 reads counter (value 0), increments it to 1.
4. P1 writes back counter = 1.
5. P2 writes back counter = 1.

Expected result: counter = 2 after both processes finish.

Actual result: counter = 1 because P2 overwrote the change made by P1.

42. Describe the Critical Section Problem? List the three necessary conditions
that a solution to the critical section problem must satisfy.

The Critical Section Problem involves ensuring that no two processes can be inside their
critical sections simultaneously when accessing shared resources. The solution must avoid
race conditions and provide mutual exclusion.

Three Necessary Conditions:

1. Mutual Exclusion: Only one process can be in the critical section at any given time.
2. Progress: If no process is in its critical section and multiple processes are waiting,
then one of the waiting processes must be allowed to enter the critical section.
3. Bounded Waiting: There must be a limit on the number of times a process can be
bypassed by other processes before it gets a chance to enter the critical section.

43. Describe how a simple mutex lock mechanism can be used to solve the
critical section problem. Support your explanation with a small pseudocode
snippet.
A mutex lock ensures that only one process can enter the critical section at a time. A mutex
is a binary flag that is locked when a process enters the critical section and unlocked when
the process leaves.

Pseudocode:

mutex lock = 0; // 0 means unlocked, 1 means locked

// Process 1
while (lock == 1); // Wait until the lock is free
lock = 1; // Lock the mutex
// Critical section code here
lock = 0; // Unlock the mutex

// Process 2
while (lock == 1); // Wait until the lock is free
lock = 1; // Lock the mutex
// Critical section code here
lock = 0; // Unlock the mutex

The mutex ensures that when Process 1 is executing its critical section, Process 2 must wait
until Process 1 releases the lock. This guarantees mutual exclusion.

44. Explain concepts of CPU scheduling.

CPU scheduling is the process by which the operating system decides which process or
thread will execute on the CPU at any given time. The goal of CPU scheduling is to
maximize CPU utilization and system throughput while minimizing response time, waiting
time, and turnaround time.

Types of CPU Scheduling Algorithms:

1. First-Come, First-Served (FCFS): Processes are executed in the order of their

arrival.
2. Shortest Job First (SJF): The process with the shortest burst time is selected next.
3. Priority Scheduling: Processes are assigned a priority, and the process with the
highest priority is selected.
4. Round Robin (RR): Processes are assigned a fixed time quantum, and each process
is given a turn to execute.
5. Multilevel Queue Scheduling: Processes are divided into multiple queues based on
their characteristics.

45. Compare between CPU-bound process and I/O-bound process.

• CPU-bound Process: These processes require more CPU time than I/O time. They
perform heavy computation and typically have longer burst times. Examples include
scientific simulations, rendering tasks, and data processing.
 • I/O-bound Process: These processes require more time for I/O operations (disk
reads, network operations) than for computation. They typically spend much of their
time waiting for I/O completion. Examples include database queries and file transfers.

Aspect CPU-bound Process I/O-bound Process

CPU Usage High CPU usage Low CPU usage
I/O Operations Few I/O operations Frequent I/O operations
Execution Runs continuously until it Alternates between I/O wait and CPU
Pattern completes execution
Mathematical calculations,
Examples File operations, database queries
simulations

46. Various Scheduling Criteria for CPU Scheduling (with Computation):

CPU scheduling aims to op4mize several criteria:

Criterion Meaning Goal

CPU Utilization Keep the CPU as busy as possible. Maximize

Number of processes completed per unit

Throughput Maximize
4me. Turnaround Time from submission to

comple4on of a

Minimize
Time process.

Time a process spends wai4ng in the ready

Waiting Time Minimize
queue.

Criterion Meaning Goal

Time from request submission to first

Response Time Minimize
response. Every process should get a fair share of

the

Fairness Maximize
CPU.
Example Computation:

• Turnaround Time = Comple4on Time – Arrival Time

• Waiting Time = Turnaround Time – Burst Time

• Throughput = Number of processes / Total 4me

• Response Time = First CPU alloca4on 4me – Arrival Time

47. Given Arrival Time {0,1,2} and Burst Time {5,3,6} — Compute Throughput,
Response Time, and Turnaround Time:

Let's assume First-Come, First-Served (FCFS) scheduling.

Process Arrival Burst Start Completion Turnaround Response

Time Time Time Time Time Time

P1 0 5 0 5 5–0=5 0–0=0

P2 1 3 5 8 8–1=7 5–1=4

P3 2 6 8 14 14 – 2 = 12 8–2=6

✅ Throughput = Number of processes / Total Time = 3 / 14 ≈ 0.214

processes/unit time

✅ Response Times = 0 (P1), 4 (P2), 6 (P3)

✅ Turnaround Times = 5 (P1), 7 (P2), 12 (P3)

48. Given Arrival {0,1,2} and Burst {5,3,6} — Compute Avg Waiting Time and Avg
Turnaround Time:

Using previous table:

Process Turnaround Time Waiting Time (Turnaround - Burst)

P1 5 5–5=0

P2 7 7–3=4

P3 12 12 – 6 = 6
✅ Average Waiting Time = (0 + 4 + 6) / 3 = 3.33 units

✅ Average Turnaround Time = (5 + 7 + 12) / 3 = 8 units

49. Define "Non-Preemptive CPU Scheduling" + Two Algorithms:

• Non-Preemptive Scheduling:
Once a process gets the CPU, it keeps it un4l it finishes or blocks itself. CPU cannot
be forcibly taken away.

• Two Non-Preemptive Scheduling Algorithms:

1. First-Come, First-Served (FCFS)

2. Shortest Job First (SJF) (non-preemp4ve version)

50. Explain "Convoy Effect":

• Convoy Effect:
It occurs when a long CPU-bound process holds the CPU, causing all other I/O-
bound processes to wait. This leads to inefficient CPU and device u4liza4on.

• Result:
CPU becomes underutilized because short, quick processes are stuck wai4ng for a
long-running one to finish.

• Example:
If a long process is scheduled first under FCFS, short processes pile up behind it like a
convoy.
51. FCFS Scheduling (Processes P1–P4)

• Processes: P1, P2, P3, P4

• Arrival Time: [0, 1, 2, 3]

• Burst Time: [10, 4, 8, 5] Gantt Chart:

| P1 |----10----| P2 |--4--| P3 |----8----| P4 |---5---|

0 10 14 22 30 35

Calculations:

Completion Turnaround Waiting Time

Process Arrival Burst Time Time (CT - AT) (TAT - BT)

P1 0 10 10 10 – 0 = 10 10 – 10 = 0

P2 1 4 14 14 – 1 = 13 13 – 4 = 9
Completion Turnaround Waiting Time
Process Arrival Burst
Time Time (CT - AT) (TAT - BT)

P3 2 8 22 22 – 2 = 20 20 – 8 = 12

P4 3 5 35 35 – 3 = 32 32 – 5 = 27

✅ Average TAT = (10 + 13 + 20 + 32) / 4 = 18.75 units

✅ Average WT = (0 + 9 + 12 + 27) / 4 = 12 units

52. Non-Preemptive SJF Scheduling (Processes P1–P4)

• Processes: P1, P2, P3, P4

• Arrival Time: [0, 1, 3, 5]

• Burst Time: [8, 5, 3, 4]

Step-by-Step:
 • At 4me 0: P1 arrives → Execute P1 (8 units)

• At 4me 8: P2(5), P3(3), P4(4) available

Shortest job = P3 (3 units) → P3 next

• Aher P3: P2 (5) and P4 (4) are there → P4 (4 units) next

• Then P2 (5 units) Gantt Chart:

| P1 |----8----| P3 |--3--| P4 |--4--| P2 |---5---|

0 8 11 15 19 24

Calculations:

Completion Turnaround Waiting

Process Arrival Burst
Time Time Time

P1 0 8 8 8–0=8 8–8=0

P2 1 5 24 24 – 1 = 23 23 – 5 = 18

P3 3 3 11 11 – 3 = 8 8–3=5

P4 5 4 15 15 – 5 = 10 10 – 4 = 6

✅ Average TAT = (8 + 23 + 8 + 10) / 4 = 12.25 units

✅ Average WT = (0 + 18 + 5 + 6) / 4 = 7.25 units

53. Non-Preemptive SJF Scheduling (Processes P1–P5)

• Processes: P1, P2, P3, P4, P5

• Arrival Time: [0, 1, 3, 5, 2]

• Burst Time: [8, 5, 3, 4, 10]

Step-by-Step:

• At 4me 0: P1 arrives → Execute P1 (8 units)

• At 4me 8: P2(5), P3(3), P4(4), P5(10) all available Shortest job = P3 (3 units) → P3
next

• Aher P3: P4 (4 units) next

 • Then P2 (5 units)

• Finally P5 (10 units) Gantt Chart:

| P1 |----8----| P3 |--3--| P4 |--4--| P2 |---5---| P5 |-----10-----|

0 8 11 15 19 24 34

Calculations:
Completion
Process Arrival Burst Turnaround Waiting

Time Time Time

P1 0 8 8 8–0=8 0

P2 1 5 24 24 – 1 = 23 23 – 5 = 18

P3 3 3 11 11 – 3 = 8 8–3=5

P4 5 4 15 15 – 5 = 10 10 – 4 = 6

P5 2 10 34 34 – 2 = 32 32 – 10 = 22

✅ Average TAT = (8 + 23 + 8 + 10 + 32) / 5 = 16.2 units

✅ Average WT = (0 + 18 + 5 + 6 + 22) / 5 = 10.2 units

54. What is Context Switching?

• Context Switching is the process of saving the state of a currently running
process so that it can be resumed later and loading the saved state of another
process to start/resume its execu4on.

• Why is it Necessary?

o It allows multitasking (running mul4ple processes) on a single CPU.

o It enables processes to share CPU time fairly and supports efficient CPU
utilization.

55. Two Components of Process's Context Saved During a Context Switch:

1. CPU Registers
(e.g., Program Counter, Stack Pointer, general-purpose registers)

2. Process Control Block (PCB)

(includes process state, memory management info, etc.)
Alright! Let’s go step-by-step and answer your ques4ons 56–60 clearly:

56. Context Switching in Preemptive vs Non-Preemptive Scheduling

Feature Preemptive Scheduling Non-Preemptive Scheduling

Can happen any4me (higher priority Only when process terminates

process arrives or 4me slice ends). or blocks (voluntarily).
When Switch
Occurs

Number of
Context Switches More context switches. Fewer context switches.

CPU Overhead Higher overhead. Lower overhead.

✅ Preemptive scheduling typically incurs more context switches because processes can
be interrupted at any 4me.

57. Information Stored During a Context Switch

✅ CPU-Related Information:

• Program Counter (PC)

• CPU Registers (general purpose)

• Stack Pointer

• Processor Status Word (flags)

✅ Memory-Related Information:

• Memory management informa4on (page table base address, segment tables)

• I/O status informa4on

• Open file tables and buffers (some4mes)

58. Diagram + Steps: Context Switch Between P1 and P2 Here's a simple diagram
layout:

P1 Running

Save P1's State (Registers, PC, Stack Pointer)

Update PCB of P1

Select P2 from Ready Queue

Load P2's State (Registers, PC, Stack Pointer)

P2 Running

Explanation of Steps:

1. Save P1’s context (registers, program counter, etc.) into P1’s PCB.

2. Update P1’s state to "Ready" or "Wai4ng."

3. Select next process (P2) from the ready queue (based on scheduler decision).

4. Load P2’s context (restore CPU registers, program counter, stack pointer from P2’s
PCB).

5. Start executing P2.

59. Detailed Steps in Context Switching + Process Isolation Steps Involved:

1. Interrupt/Trap Occurs
(Timer interrupt, I/O interrupt, or system call triggers a context switch.)

2. Save Context of Current Process (P1)

o Save CPU state (registers, PC) into the PCB of P1.

 3. Update PCB and Scheduler

o Mark P1 as "Ready" or "Blocked."

4. Choose Next Process (P2)

o Scheduler picks a process from the ready queue.

5. Restore Context of P2 o Load CPU registers, PC, etc., from P2’s PCB.

6. Transfer Control to P2

o P2 starts/resumes execu4on.

✅ Process Isolation & Data Consistency:

• Each process has its own address space (protected by hardware MMU - Memory
Management Unit).

• OS ensures PCBs are maintained separately.

• No process can access memory/data of another process unless explicitly shared.

60. Round Robin Scheduling (5 Processes, Time Quantum = 10 ms)

• Processes: P1, P2, P3, P4, P5

• CPU Time Needed per Process: 25 ms

• Time Quantum: 10 ms

• Context Switch Time: 2 ms (1 ms save + 1 ms load)

✅ (a) Gantt Chart:

Each process needs 25 ms, so each will run 3 rounds:

• First 10 ms

• Next 10 ms

• Last 5 ms

Timeline (with context switch after each process):

| P1 | P2 | P3 | P4 | P5 | P1 | P2 | P3 | P4 | P5 | P1 | P2 | P3 | P4 | P5 |

0 10 20 30 40 50 60 70 80 90 100 105 110 115 120 125

✅ (b) Total Context Switching Time:

• Aher each process execu4on, there is a context switch.

• Number of switches = Number of transitions = (15 - 1) = 14 context switches.

• Time per context switch = 2 ms.

Total context switching 4me = 14 × 2 = 28 ms.

✅ (c) CPU Utilization:

• Total Time = End 4me = 125 ms

• Useful Work (CPU execution only) = CPU 4me for processes = 5 × 25 = 125 ms

• But CPU lost time = 28 ms in context switches.

So, actual CPU work time = 125 – 28 = 97 ms.

CPU U4liza4on (%) = (Useful Time / Total Time) × 100

= (97 / 125) × 100
≈ 77.6%

✨ Quick Summary:
Part Answer

Ganv Chart P1 P2 P3 P4 P5 P1 P2 P3 P4 P5 P1 P2 P3 P4 P5
Part Answer

Context Switch Time 28 ms

CPU U4liza4on 77.6%

61. Compare Context Switching Scenarios

✅ (a) Preemptive vs Non-Preemptive Scheduling
Feature Preemptive Non-Preemptive

Timer interrupt, higher priority Voluntary (process

Switching Trigger
process arrival finishes or blocks)

Frequency of Switches More frequent Less frequent

Context Switch
Overhead Higher Lower
✅ (b) User-Level Threads vs Kernel-Level Threads

Feature User-Level Threads Kernel-Level Threads

Context Switch Very fast (no kernel Slower (requires kernel

Speed involvement) mode switch)

Managed By User-space library Opera4ng system (kernel)

✅ (c) Single-Core vs Multi-Core Systems

Feature Single-Core Multi-Core

Context Switching Yes (only one task at Some4mes (each core can
Needed a 4me) run a process)

No (only pseudo-
Parallel Execu4on Yes (true parallelism)
parallelism)

62. Define Context Switching and Related Aspects Definition:

Context Switching is the process of saving the state of the currently running process or
thread and loading the state of the next one to be scheduled.

✅ (a) Role of Process Control Block (PCB)

• PCB stores informa4on about:

 o Process ID, process state o CPU registers, memory management info o Open

files, accoun4ng informa4on

• During context switch, current PCB is updated, and new PCB is loaded. Example:
While switching from Process P1 to P2, OS saves P1's PC and registers into P1’s PCB and
loads P2’s informa4on from its PCB.

✅ (b) Thread vs Process Context Switching

Aspect Thread Context Switch Process Context Switch

Memory Address Shared (no need to switch Different (switch

Space memory space) memory space too)

Speed Faster (less overhead) Slower (more overhead)

✅ (c) How Context Switching Enables Multitasking

• Mul4tasking allows mul4ple processes or threads to share CPU time efficiently.

• By rapidly switching between tasks, OS creates the illusion that all tasks are running
simultaneously.

• Example: Typing a document while listening to music.

63. Basic States of a Process (State Transition Diagram) Here are the basic states:
New → Ready → Running → Wai4ng → Terminated

↑ ↓ ↑

(Ready Queue) (I/O or event wait) New:

Process being created.

• Ready: Wai4ng to be assigned CPU.

• Running: Currently execu4ng.

• Waiting: Wai4ng for I/O or event.

• Terminated: Execu4on finished.

64. What is the 'Ready' State?
✅ Ready State means the process is:

• Prepared to run and waiting for CPU alloca4on.

• It has all resources except the CPU.

• Processes are placed in the Ready Queue managed by the scheduler.

Example:
When a process finishes wai4ng for I/O and now just needs CPU 4me.

65. Difference Between 'Ready' and 'Running' States

Aspect Ready State Running State

CPU Usage Not using CPU yet Ac4vely using the CPU

Status Wai4ng to be scheduled Currently scheduled Managed By Scheduler CPU

Execu4on Unit

Simple:

• Ready = "I'm ready, please choose me!"

• Running = "I'm chosen and working now!"

66. Conditions for Transition from 'Waiting' to 'Ready' State

✅ A process in the Waiting state moves to the Ready state when the event it was waiting
for is completed.

Examples of such events:

• Comple4on of I/O opera4on (e.g., file read, printer output)

• Signal received (e.g., external event or 4mer)

✅ Key Point:
The process becomes eligible for CPU again but must wait in the Ready Queue un4l the
scheduler assigns it the CPU.

67. How a Process Moves from Creation to Termination (State Transition Concept)
Lifecycle of a process:

1. New:

o Process is being created (by system call like fork()).

2. Ready:

o Aher ini4aliza4on, it enters the ready queue, awai4ng CPU 4me.

3. Running:

o Scheduler selects it; the process starts execu4on.

4. Waiting:

o If the process requests I/O or an event, it moves to wai4ng.

5. Ready (again):

o Once I/O/event is completed, it goes back to ready.

6. Running (again):

o Scheduler picks it again.

7. Terminated:

o Aher execu4on is complete, process moves to terminated (exit).

✅ In multitasking systems:
Mul4ple processes constantly cycle between Ready, Running, and Waiting before
reaching Termination.

68. Complete Process State Transition Diagram

✅ Here's a well-labeled diagram (text form):

+-------> Running <-------+

 | | |

| ↓ |

New --> Ready --> Running --> Wai4ng

| |

↓ ↓

Terminated Back to Ready

✅ Explanation of States:

• New: Process created.

• Ready: Wai4ng for CPU.

• Running: Execu4ng.

• Waiting: Wai4ng for I/O or event.

• Terminated: Process finished execu4on.

✅ Key Transitions:

• Ready → Running: CPU scheduler dispatches the process.

• Running → Waiting: Process requests I/O.

• Waiting → Ready: I/O completed.

• Running → Terminated: Process finishes execu4on.

• Running → Ready: Preemp4on (due to 4me slice expira4on or higher-priority

process arrival).

69. Structure and Role of a Process Control Block (PCB)

✅ Structure of a PCB includes:

• Process Identification: PID, parent PID

• Processor State Information: CPU register values, program counter

• Memory Management Info: Page tables, segment tables

• Accounting Information: CPU 4me used, process priority

 • I/O Status: List of open files, I/O devices assigned ✅ Role of PCB:

• Acts as a "snapshot" of the process at any moment.

• During context switching, PCB helps save and restore process states.

• It allows the opera4ng system to manage multiple processes efficiently without

losing process-specific data.

70. Information Stored in PCB + OS Usage During Context Switch

✅ Information typically stored in PCB:

Category Details

Process Iden4fica4on PID, PPID (parent PID)

CPU State Program Counter, Registers

Memory Informa4on Base and limit registers, page tables

Process State Ready, Running, Wai4ng, etc.

Accoun4ng Info CPU usage, execu4on 4me

I/O Info Open files, allocated devices

✅ How OS Uses PCB During Context Switching:

• Saving:
When a process is preempted, OS saves its CPU state into its PCB.

• Loading:
Before resuming a process, OS loads the CPU state from the process’s PCB.

• Scheduling:
Scheduler uses PCB informa4on to pick the next process to run.

• Management:
PCB helps OS keep track of resource usage and status of every process.

✅ QUICK SUMMARY TABLE:

Qn Focus Key Point

Wai4ng → Ready
Aher I/O/event comple4on
66 transi4on

Crea4on to New → Ready → Running → Wai4ng →

67
Termina4on flow Ready → Running → Terminated

Text diagram with New, Ready, Running, Wai4ng,

68 Full State Diagram
Terminated

69 PCB Role Saves all process informa4on

PCB Usage in
70
Context Switch Save/load CPU state, help scheduling

71. What information does a PCB store for a process in an operating system?
✅ A Process Control Block (PCB) stores:

• Process ID (PID) and Parent PID

• Process State (Ready, Running, Wai4ng, etc.)

• Program Counter (address of next instruc4on)

• CPU Registers (all CPU-specific data)

• Memory Management Info (page tables, segment tables)

• Accounting Info (CPU usage, process priority)

• I/O Information (open files, devices in use)

👉 The PCB acts like a "blueprint" of the process at any time!

72. Define Multithreading

✅ Multithreading is the ability of a single process to have multiple threads execu4ng
independently but sharing the same resources (like memory).
 • Each thread represents a separate flow of control (like miniprograms).

• Threads within a process can run concurrently and communicate easily.

Example:
A web browser:

• One thread loads images

• One thread handles user input

• One thread renders the page

73. What is Thread Synchronization?

✅ Thread Synchronization is the technique of controlling the execution order of threads
to prevent conflicts when accessing shared resources.

• It avoids race conditions.

• Tools like mutexes, semaphores, and monitors are used.

Example:
Two threads trying to update the same bank account balance at the same 4me →
Synchroniza4on ensures updates happen safely.

74. Three Differences between User-Level and Kernel-Level Threads

Feature User-Level Threads Kernel-Level Threads

Managed By User-space library Opera4ng System (kernel)

Speed of Context Very fast (no kernel Slower (kernel needs to switch
Switching involvement) contexts)

Kernel knows and

Visibility to Kernel Kernel is unaware
manages each thread

75. Three States of a Thread ✅ Three basic thread states:

 • Running:
The thread is currently being executed by the CPU.

• Ready:
The thread is ready to run but wai4ng for CPU alloca4on.

• Blocked (Waiting):
The thread is wai4ng for some event (e.g., I/O comple4on) before it can con4nue.

(There are other states too, like New and Terminated.)

76. Differentiate Between Thread and Process (At least Four Points)
Aspect Thread Process

Shares memory with other

Has separate memory space
Memory Usage threads

Crea4on
Low (lightweight) High (heavyweight)
Overhead

Difficult (needs IPC

Communica4on Easy (shared memory)
mechanisms)

Threads within the same

Dependency process are dependent Processes are independent

✅ QUICK RECAP TABLE:

Qn Focus Key Point

71 PCB contents PID, State, PC, CPU info, Memory info

72 Mul4threading Mul4ple threads in a single process

73 Thread Synchroniza4on Safe access to shared resources

74 User vs Kernel Threads Management, speed, kernel awareness

75 Thread States Running, Ready, Blocked

76 Thread vs Process Memory, overhead, communica4on

77. Explain Dekker's Algorithm

✅ Dekker’s Algorithm is the first known software solution for the critical section
problem involving two processes.

• It ensures mutual exclusion (only one process enters cri4cal sec4on at a 4me).

• It uses flags and a turn variable to control access.

Key Idea:

• Each process sets its flag to indicate interest in entering the cri4cal sec4on.

• If both want to enter at the same 4me, turn variable decides who goes first.

Simple Pseudocode:

do { flag[i] = true; while (flag[j]) { if

(turn != i) { flag[i] = false; while

(turn != i) ; // busy wait flag[i] = true;

// Cri4cal Sec4on

...

turn = j; flag[i]

= false;

// Remainder Sec4on

...

} while (true);

78. Key Challenges in Thread Management

✅ Main challenges:

• Synchronization:
Ensuring threads do not corrupt shared resources.

• Deadlock and Starvation:

Threads wai4ng forever or some threads being ignored.

• Scheduling:
Efficiently alloca4ng CPU 4me among many threads.

• Context Switching Overhead:

Too frequent switching can waste CPU 4me.

• Resource Allocation:
Managing limited system resources (memory, files, etc.).

79. Concept of Threads and Their Management in Modern OS

✅ What are Threads?

• Threads are lightweight processes inside a process.

• Mul4ple threads share the same address space, files, and resources but execute
independently.

✅ Thread Management includes:

• Creation and Termination:

Create threads efficiently using APIs like pthread_create().

• Scheduling:
Scheduler manages thread execu4on order (can be preemp4ve or coopera4ve).

• Synchronization:
Mechanisms like mutexes, semaphores, and locks prevent race condi4ons.

• Thread Libraries:

o POSIX Threads (pthreads) for UNIX/Linux o Windows

threads API

✅ Modern OS Support:

• Multithreading is supported at both user-level and kernel-level.

 • Examples: Windows, Linux, macOS all provide rich thread management capabili4es.

80. Key Variables Used in Peterson's Algorithm

✅ Peterson’s Algorithm uses two main variables: Variable Purpose flag[i] Indicates

if process i wants to enter cri4cal sec4on turn Indicates which process’s turn it is to

enter cri4cal sec4on

✅ These two variables ensure:

• Mutual Exclusion

• Progress

• Bounded Waiting

Note: Peterson’s Algorithm also works for two processes only.

81. Drawbacks of Using Dekker's Algorithm

✅ Potential Drawbacks:

• Busy Waiting:
Processes constantly check condi4ons, was4ng CPU 4me (no CPU yielding).

• Complexity:
Difficult to understand and implement correctly.

• Limited to Two Processes:

Not scalable to more than two processes without major modifica4ons.

• Hardware Dependency:
Works poorly on modern architectures with complex memory models (caching, out-
of-order execu4on).

✅ In modern systems, hardware-supported synchronization (like atomic instructions) is

preferred.

✅ QUICK SUMMARY TABLE:

Qn Focus Key Point

First sohware solu4on for mutual

77 Dekker’s Algorithm
exclusion

Thread Management
78
Challenges Synchroniza4on, scheduling, deadlocks
Qn Focus Key Point

79 Threads in Modern OS Crea4on, Scheduling, Synchroniza4on

Peterson’s Algorithm
80 flag[i], turn
Variables
Dekker’s Algorithm
81
Drawbacks Busy wai4ng, complexity, 2-process limit

82. Pseudocode Implementation of Peterson's Algorithm for Two Processes

Peterson's Algorithm is a sohware solu4on for the cri4cal sec4on problem for two
processes. Here’s how the algorithm works in pseudocode: // Shared variables flag[2]
= {false, false}; // flag[i] = true if process i wants to enter the cri4cal sec4on turn = 0;
// turn variable to decide whose turn it is

// Process i (0 or 1) do {

// Indicate interest in entering the cri4cal sec4on flag[i] = true;

// Give the other process a chance to enter

turn = 1 - i;

// Wait un4l the other process has finished or it’s our turn while (flag[1 - i] &&

turn == 1 - i) {

// Busy-wait
}

// Cri4cal sec4on code

...

// Exit the cri4cal sec4on flag[i] =

false;

// Remainder sec4on code

...

} while (true);

• flag[i] indicates whether process i wants to enter the cri4cal sec4on.

• turn ensures mutual exclusion by giving one process priority if both processes try to
enter at the same 4me.

83. Can Peterson's and Dekker's Algorithms Be Extended to More Than Two
Processes?

✅ Peterson's Algorithm:

• No, Peterson's Algorithm is designed for two processes only.

• Extending it to more than two processes requires more complex synchronization

and the original algorithm's structure would not suffice.

• One possible extension is to use a generalized N-process Peterson’s Algorithm, but

it becomes complex and inefficient as the number of processes grows.

✅ Dekker's Algorithm:

• No, Dekker's algorithm is similarly designed for two processes.

• Extending Dekker’s algorithm to more than two processes would make it

complicated and inefficient.

• For N processes, more advanced synchroniza4on mechanisms (like Lamport’s

Bakery Algorithm) are used instead.
84. Are Dekker's and Peterson's Algorithms Commonly Used in Modern Operating
Systems for Process Synchronization? Why or Why Not?

✅ No, Dekker's and Peterson's algorithms are not commonly used in modern operating
systems for process synchroniza4on.

Reasons:

• Inefficiency: Both algorithms rely on busy waiting (spinning), which is CPU-

inefficient. Modern OS use blocking techniques like mutexes, semaphores, or
monitors instead.
• Scalability Issues: Both algorithms were designed for two processes, so they are
not prac4cal for modern systems with many concurrent processes.

• Lack of Hardware Support: Modern OS use hardware support like atomic

instructions to ensure efficient synchroniza4on, which makes older algorithms less
relevant.

85. Describe Dekker's Algorithm for Mutual Exclusion

Dekker’s Algorithm ensures mutual exclusion for two processes trying to enter a cri4cal
sec4on.

Steps:

1. Both processes have a flag indica4ng their desire to enter the cri4cal sec4on.

2. A turn variable decides which process will be allowed to enter if both try at the
same 4me.

3. Process 1:

o Sets its flag to true (indica4ng it wants to enter).

o If Process 2 has its flag set and it’s not its turn, it waits (busy-wait). o If
it’s its turn or Process 2 is not interested, it enters the cri4cal sec4on.

4. Process 2 works similarly and follows the same rules.

Ensuring mutual exclusion:

• Only one process can enter the cri4cal sec4on at any 4me because one process is
always given priority based on the turn variable.
86. Compare and Contrast Dekker's and Peterson's Algorithms Aspect Dekker’s

Algorithm Peterson’s Algorithm

Ensures mutual exclusion Same, but uses a simpler

Mutual using a turn variable and approach with a turn
Exclusion
flags. variable.

More efficient than

Less efficient due to busy
Efficiency Dekker’s in terms of
wai4ng and complexity.
simplicity.

Practical Use in Rarely used in modern Rarely used; newer

Modern OS systems. methods are preferred.

Scalability Limited to two processes. Limited to two processes.

More complex, harder to Simpler, easier to

Complexity implement correctly. implement than Dekker's.

87. In What Scenarios is Peterson's Algorithm Preferred Over Other

Synchronization Mechanisms?

✅ Peterson’s Algorithm is rarely preferred in modern systems, but it might be used in

certain educa4onal or theore4cal contexts to demonstrate:

1. Teaching synchronization:
As a simple and easy-to-understand algorithm for two processes.

2. Small-scale systems:
In systems with very few processes, Peterson's algorithm could be considered.

Advantages:

• Simple and elegant for two processes.

• It ensures mutual exclusion, progress, and bounded wai4ng.

Limitations:

• Busy waiting causes inefficiency in CPU usage.

• Limited to two processes, making it imprac4cal for modern systems with many
concurrent tasks.

88. Analyze Whether Deadlock is Possible in Either Peterson's or Dekker's

Algorithm

✅ Deadlock is not possible in either Peterson’s or Dekker’s algorithm because both

algorithms ensure:
• Progress: If one process wants to enter the cri4cal sec4on, it will eventually be able
to do so (no deadlock where all processes are stuck wai4ng).

• Bounded Waiting: Every process has a limit on how long it must wait to enter the
cri4cal sec4on.

Reasons Deadlock is avoided:

• Peterson’s Algorithm ensures one process will always get the cri4cal sec4on.

• Dekker’s Algorithm avoids deadlock by using a turn-based system that ensures that
one process will proceed.

QUICK RECAP TABLE:

Qn Focus Key Point

Peterson's Algorithm
82 Flags, turn variable for mutual exclusion
Pseudocode

Extending Peterson’s &

83 No, both are limited to two processes
Dekker’s Algo

Rarely used due to inefficiency and scalability

84 Use in Modern OS
issues

85 Dekker’s Algorithm Uses turn and flag variables for mutual exclusion
 Compare Dekker’s vs
86 Differences in simplicity, efficiency, scalability
Peterson’s Algorithms

When to prefer Peterson’s

87 Educa4on or very small-scale systems
Algorithm
Deadlock in Peterson’s or
88
Dekker’s Algo Deadlock is not possible; both algorithms avoid it