Banarsidas Chandiwala Institute of

Information Technology

OS ASSIGNMENT

Name – KUSHAL
Enrolment No. 04311104424
MCA – I (2024-2026)
Ques 1. Compare Monolithic Kernel and Microkernel. Which type of kernel is used in Microsoft Windows 10?

ANSWER:

Comparison of Monolithic Kernel and Microkernel

Monolithic Kernel:

The monolithic kernel is a design where all essential operating system services run in the kernel space, creating a
single, large process running entirely in privileged mode. Key services, such as device drivers, file system
management, memory management, and other core functionalities, are integrated into a single executable binary.
Here are some important characteristics of monolithic kernels:

1. Performance: Since all services are in the kernel space, the communication between services (like device
drivers and memory management) occurs at high speed, without the need for extensive context switching.
This results in faster operations and low latency.

2. Design Simplicity: Monolithic kernels use a straightforward approach to OS design, allowing direct access
to resources and easier management of system calls within a single address space.

3. Resource Access and Stability: By running everything in one space, monolithic kernels can face stability
challenges. If one component fails (such as a driver), it can crash the entire system, as there is no isolation
between services.

4. Example: Linux OS is a widely known example of a monolithic kernel, as it manages resources efficiently
while leveraging high-speed communication between services.

Microkernel:

The microkernel architecture, on the other hand, is designed to keep only the most essential services, such as
memory management, process scheduling, and inter-process communication (IPC), in the kernel space. All other
services, like device drivers and file systems, are implemented in user space as isolated processes. Key features
include:
04811104424 KARTIK KAUSHIK MCA -1 SEM
 1. Modularity and Isolation: Microkernels are highly modular; non-essential services (e.g., drivers) run in
user mode, separate from the core kernel. This creates a more stable system, as errors in a user-mode
service are less likely to compromise the entire OS.

2. Security: Microkernels are considered more secure due to service isolation. Each service operates
independently, limiting the impact of any single service's failure on overall OS stability.

3. Performance Overhead: The main drawback is the need for more frequent context switches between
kernel and user modes, increasing overhead and reducing overall performance. This design, though secure,
can be less efficient in terms of speed due to the added communication overhead.

4. Example: QNX and MINIX are examples of systems based on the microkernel architecture, emphasizing
modularity and robustness over raw performance.

Microsoft Windows 10:

Kernel Architecture of Microsoft Windows 10

Microsoft Windows 10 uses a hybrid kernel, which integrates features from both monolithic and microkernel
architectures. Here’s a breakdown of its hybrid design:

1. Core Components in Kernel Mode: Like a monolithic kernel, Windows 10 has essential services—such as
memory management, process scheduling, and system calls—running in kernel space. This setup allows for
high performance by reducing the communication overhead typical of pure microkernels.

2. Modularity for Stability: Although it operates similarly to a monolithic kernel, Windows 10 includes
modularity aspects for certain services, which run in user mode. For example, some device drivers and
subsystems may run outside of kernel mode to prevent entire-system crashes in the event of a service
failure.

04811104424 KARTIK KAUSHIK MCA -1 SEM

 3. Interoperability and Compatibility: The hybrid kernel architecture allows Windows 10 to support a broad
range of applications and hardware without sacrificing performance. The structure also helps with backward
compatibility with older Windows versions, maintaining consistency across different Windows-based
devices.

4. Balance of Security and Performance: The hybrid kernel achieves a compromise between the
performance of a monolithic kernel and the stability and security of a microkernel. While the kernel handles
critical tasks efficiently in kernel mode, it also maintains separation for potentially less stable processes,
enhancing the system’s robustness.

5. Examples of Hybrid Kernel Features: Windows 10 uses elements like a Hardware Abstraction Layer (HAL)
and subsystem servers (e.g., Win32 API) to interact with hardware and applications, allowing it to support
diverse software while remaining stable.

The Windows 10 hybrid kernel combines the performance advantages of a monolithic kernel with the
stability and security benefits of a microkernel. By balancing these aspects, Windows 10 can deliver high
performance for end-users while retaining modularity for more reliable operations.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 2. Illustrate the Bootstrap Process of an Operating System?

ANSWER:

The Bootstrap Process of an Operating System

The bootstrap process is a series of steps that an operating system performs to start up and initialize a computer
system. This process takes place every time a system is powered on or restarted. The term "bootstrap" refers to the
system "pulling itself up by its bootstraps," starting from minimal instructions in hardware and loading the full OS.
The sequence is designed to ensure that all hardware and software components are prepared for regular use.

• Step 1: Power On and Power-On Self-Test (POST)

1. Power On: When the power button is pressed, the system receives an electrical signal, powering up essential
hardware components like the CPU, memory, and motherboard.

2. POST (Power-On Self-Test): The BIOS (Basic Input/Output System) or UEFI (Unified Extensible Firmware Interface)
firmware begins by executing the POST. POST is a diagnostic testing sequence that verifies the functionality and
integrity of hardware components, such as RAM, CPU, storage drives, and other peripherals.

3. Error Detection: If any critical hardware fails, the POST process may halt the boot process, typically showing an
error message or beep code indicating the issue. If all tests pass, the system continues to the next phase.

• Step 2: Boot Loader Activation

1. BIOS/UEFI Execution: After POST, the BIOS/UEFI firmware locates the bootable storage device where the
operating system resides (often a hard disk, SSD, or external drive).

2. Bootloader Identification: The firmware identifies the Master Boot Record (MBR) or GUID Partition Table (GPT) on
the storage device, which contains the location of the bootloader. The bootloader is a small program that facilitates
the loading of the OS.

3. Loading the Bootloader: The BIOS/UEFI loads the bootloader into memory. In modern systems, bootloaders are
sophisticated enough to support multiple OS options, like GRUB (for Linux) or the Windows Boot Manager, allowing
users to select an OS if multiple are installed.

• Step 3: Kernel Loading

1. Loading the Kernel: The bootloader’s primary job is to locate the operating system kernel and load it into RAM.
The kernel is the core component of the operating system, managing system resources and facilitating interactions
between hardware and software.

2. Kernel Selection and Parameters: If multiple OS kernels are available, the bootloader allows the user to select
one. The user can also pass special parameters to the kernel, such as diagnostic or safe modes, which may alter how
the OS loads.

3. Transfer of Control: Once the kernel is loaded into memory, the bootloader hands over control to the kernel,
marking the end of the bootloader’s role.

• Step 4: Kernel Initialization

1. Hardware Initialization: The kernel initializes essential hardware components, setting up drivers to communicate
with hardware like the CPU, memory, and I/O devices.

04811104424 KARTIK KAUSHIK MCA -1 SEM

2. Setting Up Data Structures: The kernel sets up data structures and memory tables for managing resources,
including memory allocation, process scheduling, and interrupt handling. These structures are critical for the OS to
maintain system stability and efficiency.

3. Device Driver Loading: The kernel loads device drivers for hardware peripherals, enabling communication
between the OS and devices like graphics cards, network adapters, and input devices.

4. System Services Preparation: Essential system services are prepared for execution. This may include loading low-
level OS services that handle file management, security protocols, and system monitoring.

• Step 5: User Space Initialization

1. Loading System Daemons: The OS begins loading necessary background services, known as daemons in
Unix/Linux or services in Windows. These processes handle tasks like network management, timekeeping, and
logging.

2. Activation of User Space: The OS prepares the user space, where user applications and services operate. This
separation of kernel and user spaces is vital for system security and stability, preventing user applications from
directly interfering with the core OS.

3. User Login Services: The OS initiates user login services, which provide the login prompt, enabling users to
authenticate and access their accounts. Once a user logs in, the OS loads the desktop environment or command
shell, giving access to applications and tools.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 3. Write the Peterson’s Algorithm (Pseudo Code) to Solve Critical Section Problem?

ANSWER:

int turn;

boolean flag[2] = {false, false};

Process P0:

flag[0] = true;

turn = 1;

while (flag[1] && turn == 1);

// Critical Section

flag[0] = false;

Process P1:

flag[1] = true;

turn = 0;

while (flag[0] && turn == 0);

// Critical Section

flag[1] = false;

Peterson's algorithm uses two flags and a turn variable to ensure mutual exclusion in critical sections for two
processes.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 4. What is a Distributed Operating System? Compare Client-Server Computing and Peer-to-Peer Computing?

ANSWER:

Distributed Operating System (DOS) is a type of operating system that manages a collection of independent
computers and makes them appear to users as a single cohesive system. These systems coordinate resources and
tasks across networked computers, or "nodes," allowing them to work together seamlessly. In a DOS, tasks are
distributed among different machines, and resources are shared across the network, creating a powerful, scalable
computing environment.

The primary goal of a distributed operating system is to achieve transparency in resource sharing, process
management, and inter-process communication across multiple computers. Distributed OSs offer benefits like
improved performance, fault tolerance, and scalability, making them ideal for applications in fields such as scientific
computing, data centers, and cloud computing.

Key Characteristics of Distributed Operating Systems:

1. Transparency: The system hides the complexities of distributed resources from users, making it appear as a single,
unified system.

2. Fault Tolerance: Distributed OSs have the ability to recover from hardware or software failures by redistributing
tasks to other nodes.

3. Scalability: New nodes can be added to the system without significant changes to its structure, improving the
overall capacity and performance.

4. Parallel Processing: Tasks can be divided among different machines, allowing for faster processing and efficiency.

Comparison of Client-Server Computing and Peer-to-Peer Computing

Distributed systems can be implemented using two primary models: Client-Server Computing and Peer-to-Peer
(P2P) Computing. Both models support distributed resource sharing and communication, but they have distinct
architectures, advantages, and limitations.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Client-Server Computing

In Client-Server Computing, the network consists of dedicated servers that provide resources and services, and
client devices that request and utilize these services. This architecture is often used in environments where
resources (such as databases, files, or applications) need to be centralized and managed effectively.

1. Centralized Control: Servers control and manage resources, making it easier to monitor, update, and maintain.
This centralized structure provides better security and simplifies the administration of resources.

2. Defined Roles: Servers and clients have specific roles. Servers are responsible for storing data and executing tasks,
while clients make requests and consume the results. This clear division reduces conflicts and enables efficient
resource management.

3. Performance and Reliability: Client-server models can face bottlenecks if too many clients access a server
simultaneously, potentially slowing down performance. Additionally, if a server fails, client access to resources is
disrupted, affecting reliability.

4. Examples: Popular examples of client-server applications include web browsers accessing web servers, email
clients connecting to email servers, and applications using database servers.

5. Pros:

• Resource Sharing: Centralized servers make it easy to share resources and data across clients.
• Security: Since resources are centrally controlled, security policies can be enforced consistently.
• Efficient Management: Centralization simplifies the management, monitoring, and updating of services and
resources.

6. Cons:

• Single Point of Failure: If a server fails, client access is interrupted, affecting the availability of resources.
• Scalability Challenges: As the number of clients grows, servers can become overloaded, leading to
performance degradation.

Peer-to-Peer (P2P) Computing

In Peer-to-Peer Computing, every node in the network acts as both a client and a server. Each peer can provide and
consume resources, enabling direct sharing of resources and information among nodes without relying on a central
server.

1. Decentralized Structure: There is no central authority or dedicated server. Each node functions independently,
offering and requesting resources as needed. This decentralization enables a more resilient and scalable network.

2. Resource Distribution: Each peer contributes resources to the network, which makes P2P systems ideal for
environments where high resource availability is required and can be distributed across a wide area.

3. Reliability and Redundancy: Due to the distributed nature of P2P, if one peer fails, others can still provide
resources, ensuring that the network continues to function. However, this model can face challenges with
consistency and resource management.

4. Examples: Popular P2P applications include file-sharing networks like BitTorrent, decentralized communication
platforms, and blockchain-based applications.
04811104424 KARTIK KAUSHIK MCA -1 SEM
5. Pros:

• Scalability: P2P systems can scale easily, as new nodes contribute additional resources.
• Fault Tolerance: The failure of individual nodes has minimal impact on the overall network, making it highly
resilient.
• Cost-Effective: No need for centralized servers, which reduces infrastructure costs.

6. Cons:

• Reliability and Quality Control: As nodes are independent, maintaining consistent quality and availability of
resources can be challenging.
• Security Risks: Since peers directly connect and exchange data, they may be vulnerable to malicious nodes,
making security difficult to enforce.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 5. Explain the Multi-Programmed Batch Systems and Time Sharing Systems with their Advantages and
Disadvantages?

ANSWER:

• Multi-Programmed Batch Systems:

Explanation: Multi-programmed batch systems allow multiple jobs to reside in memory simultaneously. The
operating system selects jobs from the pool, loads them into memory, and executes them one by one. When a job
waits for I/O operations, the CPU switches to another job, maximizing its utilization. There is minimal user
interaction, as jobs are processed in batches.

Advantages:

o High CPU Utilization: By switching between jobs, the system keeps the CPU busy, reducing idle time and
improving efficiency.
o Increased Throughput: More jobs are processed in less time, as the CPU can handle other jobs while one job
waits for I/O operations.

Disadvantages:

o Lack of Interactivity: Users cannot interact with the system while their jobs are being processed. Jobs are
submitted, executed, and results are returned without real-time interaction.
o Longer Wait Time for Individual Jobs: Jobs may wait in the queue for a long time if other jobs are ahead of
them, especially if there are I/O-bound processes.

• Time-Sharing Systems:

Explanation: Time-sharing systems allow multiple users to access the system simultaneously by rapidly switching the
CPU among user processes. Each user gets a small time slice, allowing them to interact with the system in real time.
This approach gives the illusion that each user has their own dedicated system.

Advantages:

o Interactive and User-Friendly: Users can interact with their programs in real time, making it ideal for
environments requiring immediate responses, such as online applications.
o Efficient Resource Utilization: The system manages resources efficiently across multiple users, ensuring that
no single job monopolizes the CPU.

Disadvantages:

o Potential for High Overhead: Rapid switching between tasks introduces overhead, as context switches
consume CPU time and resources.
o Complex Scheduling: Ensuring fair and efficient allocation of CPU time among users requires sophisticated
scheduling algorithms, adding complexity to the system.

04811104424 KARTIK KAUSHIK MCA -1 SEM

 Multi-Programmed Batch Systems

Time-Sharing Systems

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 6. Why is Inter-Process Communication Important? Compare Shared Memory and Message Passing Models
of IPC?

ANSWER:

Importance of Inter-Process Communication (IPC)

Inter-Process Communication (IPC) is crucial in an operating system as it enables processes to interact, coordinate,
and exchange data. This is essential for multitasking systems, where multiple processes run concurrently and may
need to cooperate to perform a task. IPC allows processes to:

1. Synchronize Operations: Ensures that processes coordinate effectively, preventing race conditions and conflicts
over shared resources.

2. Share Data: Facilitates data sharing between processes, which is vital in applications where tasks need to
collaborate by exchanging information.

3. Improve Efficiency: Enables parallel processing by allowing processes to perform specific parts of a task
simultaneously, enhancing system performance.

4. Enable Modularity: IPC allows large applications to be built as modular components that communicate with each
other, making software easier to manage and maintain.

Comparison of Shared Memory and Message Passing Models of IPC

IPC mechanisms primarily use two models: Shared Memory and Message Passing. Both have unique methods of
data exchange and synchronization, making them suitable for different applications and system architectures

Shared Memory Model

In the Shared Memory Model, processes communicate by sharing a specific region of memory. This area can be
accessed by multiple processes, enabling fast data exchange without involving the kernel after the initial setup.

1. Data Exchange: Processes can directly read from and write to the shared memory, which allows high-speed data
transfer. This model is often used in systems with high performance requirements.

2. Synchronization Mechanisms: Since multiple processes access the same memory, there is a risk of data
inconsistency. Synchronization mechanisms such as semaphores and mutexes are required to manage access,
ensuring that only one process modifies the data at a time.

3. Efficiency: Shared memory is generally faster than message passing because it eliminates the need for copying
data between processes. Instead, processes operate on the same data structure in memory.

4. Examples: Shared memory is widely used in applications requiring real-time data sharing, such as multimedia
processing, gaming, and database management systems.

5. Pros:

o High Speed : Direct memory access eliminates data copying overhead.

o Suitable for Large Data : Ideal for transferring large data sets efficiently.

6. Cons:

o Complex Synchronization : Requires careful handling of concurrency issues.

04811104424 KARTIK KAUSHIK MCA -1 SEM

 o Limited to Same System : Only works for processes on the same machine, making it unsuitable for
distributed systems.

Message Passing Model

In the Message Passing Model, processes communicate by explicitly sending and receiving messages through a
communication channel. Each message is a data packet that can be transmitted between processes, often using the
operating system’s IPC facilities.

1. Data Exchange: Communication occurs via message passing, where a process sends data as a message, and the
receiving process reads it. This approach is more structured and can be used across different machines in a network.

2. Simpler Synchronization: Since each message is a discrete unit of data, there is no need for complex
synchronization mechanisms. The sender and receiver communicate sequentially, reducing the risk of data races.

3. Performance: Message passing generally incurs more overhead than shared memory due to the need to copy data
between processes and, potentially, across networks. This can result in slower performance for high-frequency
communication.

4. Examples: Message passing is widely used in distributed systems and networked applications, such as
microservices, cloud applications, and remote procedure calls.

5. Pros:

o Simplicity: Easier to implement with built-in synchronization.

o Distributed Capability: Suitable for both local and remote communication, making it ideal for distributed
systems.

6. Cons:

o Lower Speed: Typically slower than shared memory due to data copying and potential network latency.
o Less Efficient for Large Data: Transmitting large volumes of data can be slow and resource-intensive.

04811104424 KARTIK KAUSHIK MCA -1 SEM

04811104424 KARTIK KAUSHIK MCA -1 SEM
Ques 7. What is an Interrupt? Explain Various Services Offered by an Operating System?

ANSWER:

An interrupt is a signal generated by either hardware or software to inform the operating system that an event
requires immediate attention. Interrupts temporarily halt the execution of the current process, allowing the OS to
address the event, after which it resumes the interrupted process. They play a crucial role in managing system
resources efficiently and responding quickly to external events.

Types of Interrupts

1. Hardware Interrupts: Triggered by external hardware devices, such as a keyboard, mouse, or network interface.
For example, when a key is pressed, the keyboard sends an interrupt to notify the CPU.

2. Software Interrupts: Initiated by software, typically to request services from the operating system. These are
often called system calls or traps.

3. Timer Interrupts: Generated by an internal system timer, allowing the OS to perform routine tasks like scheduling.

Interrupts are essential for multitasking, as they allow the operating system to manage multiple processes efficiently
by responding to events and prioritizing tasks.

Services Offered by an Operating System

Operating systems provide a variety of essential services to enable effective use of computer resources and to
support application software. Here are some of the core services offered:

1. Process Management

Process management involves creating, scheduling, and terminating processes (programs in execution). It ensures
that processes are executed efficiently and without interference. Key functions include:

o Process Scheduling: The OS uses algorithms to decide the order in which processes execute,
managing CPU time for each process.
o Multitasking: Enables multiple processes to run concurrently, maximizing CPU utilization.
o Inter-Process Communication (IPC): Allows processes to communicate and share data, enabling
cooperation between programs.
o Process Synchronization: Ensures that processes run in sync, avoiding conflicts when accessing
shared resources.

2. Memory Management

Memory management controls how memory is allocated and managed among processes. Since multiple processes
may need memory simultaneously, the OS ensures that each one has access to the necessary memory without
conflicts.

04811104424 KARTIK KAUSHIK MCA -1 SEM

 o Memory Allocation: Allocates and deallocates memory space to processes based on their
requirements.
o Virtual Memory: Allows programs to use more memory than physically available by using disk space
as an extension of RAM.
o Memory Protection: Prevents processes from accessing memory allocated to other processes,
enhancing security and stability.

3. File System Management

File system management handles the creation, deletion, and organization of files and directories. It provides users
and applications with a systematic way to store and retrieve data.

o File Storage: Manages the storage and retrieval of files on disk.

o Directory Structure: Organizes files within directories (folders) for easy navigation and management.
o Access Control: Implements permissions and access control, restricting file access based on user
roles.

4. Device Management

Device management enables communication between the system and peripheral devices, such as printers,
keyboards, and storage devices. The OS uses device drivers to interface with hardware components.

o Device Drivers: Provides a standardized interface to communicate with hardware, making it easier
for applications to use various devices.
o Device Allocation: Manages and allocates devices to processes as needed, ensuring no conflicts.
o I/O Scheduling: Controls the order in which input/output requests are processed, optimizing device
use and performance.

5. Security and Protection

Security and protection services safeguard system resources, data, and applications from unauthorized access and
potential threats. The OS enforces policies to protect user data and system integrity.

o User Authentication: Verifies user identity through methods like passwords or biometrics.
o Access Control: Manages permissions for accessing files, directories, and system resources, ensuring
that users and applications can only access what they are authorized to.
o Data Encryption: Encrypts sensitive data to protect it from unauthorized access and theft.

6. User Interface

The OS provides a user interface (UI) that allows users to interact with the system and execute commands. The UI
can be command-line-based (CLI) or graphical (GUI).

o Command-Line Interface (CLI): Allows users to type commands to perform tasks, often used by
advanced users.
o Graphical User Interface (GUI): Provides visual elements like windows, icons, and menus for easier
interaction, commonly found in desktop operating systems.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 8. Describe the Functions of a Dispatcher. Illustrate Multilevel Queue Scheduling Approach?

ANSWER

➢ Functions of a Dispatcher:

A dispatcher is a key component of the operating system's process scheduling mechanism. It plays a crucial role in
switching the CPU from one process to another, enabling multitasking and efficient CPU utilization. Here are the
main functions of a dispatcher:

1. Context Switching: The dispatcher saves the state (context) of the currently running process and loads the state of
the next process selected by the scheduler. This context includes information like registers, program counter, and
memory state.

2. CPU Allocation: Once the context switch is complete, the dispatcher allocates the CPU to the selected process,
allowing it to resume execution.

3. Setting Up User Mode: The dispatcher ensures that the selected process is set up to run in user mode (as opposed
to kernel mode), preventing the process from accessing restricted system resources.

4. Jumping to the Proper Location in the Program: The dispatcher moves the program counter to the appropriate
location in the new process, allowing it to continue from where it left off or to start from the beginning if it’s a new
process.

5. Time Management: In systems with time-sharing or round-robin scheduling, the dispatcher ensures that each
process gets a fair amount of CPU time within a defined time slice (quantum). If a process exceeds its allocated time,
it’s preempted, and the dispatcher selects the next process.

Multilevel Queue Scheduling Approach

Multilevel Queue Scheduling is a scheduling method that organizes processes into multiple separate queues based
on their priority or type. Each queue can have a different scheduling algorithm, and processes in higher-priority
queues are typically executed before those in lower-priority queues. This approach is suitable for systems where
different types of processes have distinct requirements (e.g., interactive versus batch processes).

Key Characteristics of Multilevel Queue Scheduling:

1. Multiple Queues: The system divides processes into different categories, such as:

o System Processes: High-priority processes crucial for system operations.

o Interactive Processes: Processes requiring user interaction, usually with medium priority.
o Batch Processes: Non-interactive processes that can run in the background with lower priority.

2. Independent Scheduling Policies: Each queue may have its own scheduling policy. For instance:

o System processes could use First-Come, First-Served (FCFS) for simplicity.

o Interactive processes might use Round Robin for fair time-sharing.
o Batch processes could use Shortest Job Next (SJN) or FCFS .

3. No Process Movement: Processes remain in the queue they are assigned to, without moving between queues.
Each process is allocated to a queue based on its type and priority when it arrives.

04811104424 KARTIK KAUSHIK MCA -1 SEM

4. Queue Priority: The queues themselves have priority levels. The scheduler first selects a process from the highest-
priority queue. If this queue is empty, it moves to the next one, and so on.

Illustration of Multilevel Queue Scheduling

Consider a system with three queues:

1. System Queue (highest priority) – handles critical system-level tasks, scheduled with FCFS.

2. Interactive Queue (medium priority) – handles user-interactive tasks, scheduled with Round Robin.

3. Batch Queue (lowest priority) – handles background, non-interactive tasks, scheduled with FCFS or SJN.

Here’s how scheduling works:

1. The scheduler always selects a process from the System Queue if it has any tasks, as these have the highest
priority.

2. If the System Queue is empty, the scheduler moves to the Interactive Queue and selects a task using Round Robin
to give each user process a fair share of CPU time.

3. If both the System and Interactive Queues are empty, the scheduler selects a process from the Batch Queue.

Example:

o Process A (System Process) arrives and is placed in the System Queue.

o Process B (Interactive Process) arrives and is placed in the Interactive Queue.
o Process C (Batch Process) arrives and is placed in the Batch Queue.

The scheduler’s actions:

1. Process A is executed first due to the high priority of the System Queue.

2. When Process A finishes, Process B is selected next from the Interactive Queue.

3. Once Process B completes its time slice, Process C is selected from the Batch Queue.

This approach allows the operating system to manage diverse types of processes efficiently, giving priority to
system-critical and user-interactive tasks over background jobs.

Advantages and Disadvantages of Multilevel Queue Scheduling

Advantages:

o Priority-Based Scheduling: Critical processes get immediate CPU access, enhancing system
responsiveness.
o Efficient Resource Allocation: Different types of processes are managed according to their specific
requirements.

04811104424 KARTIK KAUSHIK MCA -1 SEM

 o Customization: Each queue can have its own scheduling algorithm, making it adaptable to different
workloads.

Disadvantages:

o Rigid Queue Assignment: Processes are permanently assigned to a queue, reducing flexibility.
o Starvation Risk: Lower-priority processes in lower queues may experience starvation if higher-
priority queues are consistently busy.
o Complexity: Managing multiple queues and scheduling algorithms can increase system complexity.

Multilevel Queue Scheduling:

• Organizes processes into separate queues (e.g., for system processes, interactive processes, batch
processes).
• Each queue may have its own scheduling algorithm, and processes are assigned based on priority.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 9. Explain the Readers-Writers Problem. Write an Algorithm (Code Snippet) to Solve It Using Semaphore?

ANSWER:

Readers-Writers Problem

The Readers-Writers Problem is a classic synchronization problem in operating systems that involves processes (or
threads) accessing shared data, such as a database, in two different ways:

1. Readers: Processes that only need to read (view) the shared data and do not modify it.
2. Writers: Processes that need to write (modify) the shared data.

The main challenge in this problem is to design a system where readers and writers can access the data without
causing conflicts or inconsistencies. Specifically:

• Multiple readers should be allowed to read the data simultaneously, as reading does not affect the data's
state.
• However, writers must have exclusive access to the data to prevent data corruption. This means:
o No two writers can access the data simultaneously.
o No reader can access the data while a writer is writing.

To ensure consistency, the system must avoid situations where writers overwrite each other’s changes or where
readers read incomplete or inconsistent data while a writer is in the process of updating it.

Types of Readers-Writers Problems

There are different variations of the Readers-Writers Problem, each with different priorities:

1. First Readers-Writers Problem (Readers Priority):

o Allows multiple readers to access the shared data simultaneously, but once a writer is ready, it must
wait until all readers have completed reading.
o This gives readers priority over writers, which can cause writer starvation if there is a continuous
stream of readers.
2. Second Readers-Writers Problem (Writers Priority):
o Gives writers priority over readers to prevent writer starvation. If a writer is waiting, it can stop new
readers from accessing the data until the writer has completed its task.
o However, this can cause reader starvation if there are frequent writer requests, as readers may be
indefinitely delayed.
3. Third Readers-Writers Problem (Fair Solution):
o Aims to provide fairness by serving readers and writers on a first-come, first-served basis, preventing
both reader and writer starvation.
o This approach balances the needs of readers and writers but can be more complex to implement.

Solution to the Readers-Writers Problem

A typical solution involves the use of semaphores or mutexes to control access to the shared data and ensure proper
synchronization. Below is a basic explanation of how the solution works:

Semaphores and Variables Used:

1. Read Count: A counter to keep track of the number of readers currently accessing the data.
2. Mutex (or Lock): Used to ensure mutual exclusion when updating the read count variable.
3. Write Lock: A semaphore that allows writers exclusive access to the shared data.

Solution Logic:

04811104424 KARTIK KAUSHIK MCA -1 SEM

For Readers:

1. Before a reader starts reading, it:

o Acquires the mutex to update the read count.
o If it’s the first reader, it also acquires the write lock to prevent writers from accessing the data.
o Releases the mutex after updating the read count.
2. After the reader finishes reading:
o It acquires the mutex to update the read count.
o If it’s the last reader, it releases the write lock so writers can access the data.
o Releases the mutex.

For Writers:

1. Before a writer starts writing, it:

o Acquires the write lock to gain exclusive access to the data, blocking both other writers and readers.
2. After the writer finishes writing:
o It releases the write lock, allowing other readers or writers to access the data.

Solution Using Semaphores:

Semaphore mutex = 1;

Semaphore rw_mutex = 1;

int read_count = 0;

Reader:

wait(mutex);

read_count++;

if (read_count == 1) wait(rw_mutex);

signal(mutex);

// Reading

wait(mutex);

read_count--;

if (read_count == 0) signal(rw_mutex);

signal(mutex);

Writer:

wait(rw_mutex);

// Writing

signal(rw_mutex);

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 10. What are the Conditions to Be Fulfilled by a Solution of the Critical-Section Problem? Explain
TestAndSet() and Swap() Approaches?

ANSWER:

Conditions for solution of the Critical Section Solutions:

In concurrent programming, the critical-section problem involves designing a mechanism that allows processes to
share resources safely without interfering with each other. To achieve this, a solution must satisfy the following
three conditions:

1. Mutual Exclusion: Only one process can enter the critical section at any given time. This ensures that no two
processes are executing in their critical sections simultaneously, which prevents data inconsistencies.
2. Progress: If no process is in the critical section and multiple processes wish to enter, only those not in their
remainder sections (the parts of the program outside the critical section) should be involved in deciding
which process enters next. This ensures that the selection of the next process to enter the critical section is
not postponed indefinitely.
3. Bounded Waiting: A process waiting to enter its critical section should not have to wait indefinitely. There
must be a bound on the number of times other processes can enter their critical sections after a process has
requested entry and before it is granted access. This prevents starvation, ensuring that every process
eventually gets a chance to enter its critical section.

TestAndSet():

The TestAndSet instruction is a hardware-supported atomic operation used to manage access to the critical section.
It operates on a single bit and works as follows:

• Atomic Operation: TestAndSet is an indivisible operation, meaning it cannot be interrupted once started,
ensuring that no two processes can perform TestAndSet at the same time.
• Mechanism: The instruction reads the current value of a memory location and sets it to 1 simultaneously.
• Return Value: If the original value of the location was 0 (indicating no process is in the critical section), the
calling process can enter the critical section. If the original value was 1, another process is already in the
critical section, and the calling process must wait.

TestAndSet Pseudo Code Example:

boolean lock = false; // Shared lock variable, initially false

// Entry Section

while (TestAndSet(lock)) {

// Busy wait until lock is false

// Critical Section

// Exit Section

lock = false; // Release the lock

In this example:

• The TestAndSet instruction continuously checks and sets the lock variable.

04811104424 KARTIK KAUSHIK MCA -1 SEM

 • If the lock is false, it is set to true, allowing the process to enter the critical section.
• If the lock is already true, the process waits in a loop (busy-waiting) until the lock is available.

Advantages:

• Simple and efficient for systems that support the atomic TestAndSet instruction.
• Provides mutual exclusion.

Disadvantages:

• Busy-waiting can lead to CPU wastage, especially in systems with many processes.
• Does not inherently satisfy bounded waiting without additional mechanisms.

Swap():

The Swap instruction is another hardware-based atomic operation that swaps the values of two variables. It is
commonly used in conjunction with a "lock" variable to control access to the critical section. The Swap instruction
operates as follows:

• Atomic Operation: Swap is also an indivisible operation, ensuring mutual exclusion.

• Mechanism: A process uses Swap to exchange the value of a local variable with a shared lock variable.
o If the local variable is initially false, the process has gained access to the critical section.
o If the lock variable is true, the process must wait, as the critical section is already occupied.

Swap Pseudo Code Example

boolean lock = false; // Shared lock variable, initially false

// Entry Section
boolean key = true; // Local variable for each process
while (key == true) {
Swap(lock, key); // Attempt to enter the critical section
}

// Critical Section

// Exit Section
lock = false; // Release the lock

In this example:

• Each process has a local variable key, initially set to true.

• The Swap instruction exchanges the values of lock and key.
• If lock is false, key becomes false after the swap, and the process can enter the critical section.
• If lock is true, the process will keep swapping until lock becomes false.

Advantages:

• Like TestAndSet, Swap ensures mutual exclusion.

• Simpler for systems that support the atomic Swap instruction.

Disadvantages:

• Busy-waiting is still required, leading to CPU inefficiency.

• Does not guarantee bounded waiting, meaning starvation could occur if not implemented carefully.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 11. Explain the Function of the Ready Queue?

ANSWER:

The ready queue is a crucial component in an operating system's process management. It holds all the processes
that are ready to execute but are waiting for CPU time. When a process transitions from a new or waiting state to a
ready state, it is placed in the ready queue. The CPU scheduler (also known as the short-term scheduler) then selects
processes from this queue based on a scheduling algorithm (e.g., First-Come-First-Served, Shortest Job First, Round
Robin) to allocate CPU time. By managing the ready queue, the operating system ensures efficient and fair CPU
utilization, helping achieve smooth multitasking. The structure of the ready queue can vary, and it may be
implemented as a simple queue, priority queue, or even a tree, depending on the scheduling policy in use.

Ques 12. What is Multithreading?

ANSWER:

Multithreading is a programming technique that allows multiple threads (smaller, independent paths of execution)
to run concurrently within a single process. Each thread shares the same memory space and resources of the parent
process, but can perform different tasks simultaneously. This parallelism is beneficial in applications where tasks can
be divided into smaller units, such as web servers (handling multiple client requests), GUIs (responding to user inputs
while performing background tasks), and scientific computations. Multithreading improves CPU utilization by
keeping the CPU busy even if one thread is waiting (e.g., for I/O). It also enhances responsiveness and allows
applications to make better use of multi-core processors.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 13. What Are the Basic Requirements of Any Solution to the Critical Section Problem?

ANSWER:

To solve the critical section problem in concurrent programming, any solution must satisfy the following three
criteria:

1. Mutual Exclusion: Only one process can be in the critical section at any time. This prevents race conditions,
where two or more processes simultaneously attempt to modify shared data, leading to data
inconsistencies.
2. Progress: If no process is in the critical section, any process that wishes to enter should be allowed to do so
without indefinite delays. This ensures that decisions about which process enters the critical section do not
depend on processes that are not involved.
3. Bounded Waiting: Each process should have a limit on the number of times other processes can enter the
critical section after it has requested to enter. This prevents starvation, ensuring that all processes
eventually get a chance to access the critical section.

These requirements help ensure efficient and fair access to shared resources while avoiding issues like deadlock and
starvation.

Ques 14. Differentiate Between Multiprogramming and Multiprocessing?

ANSWER:

Feature Multiprogramming Multiprocessing

Definition Multiprogramming involves running multiple Multiprocessing involves running multiple
programs on a single CPU concurrently. processes on multiple CPUs simultaneously.
Objective The goal is to maximize CPU utilization by The goal is to increase system performance and
overlapping CPU and I/O tasks. throughput by parallel execution.
Concurrency Achieved through task switching between Achieved by actual parallel execution on
programs. multiple CPUs or cores.
System Commonly found in single-processor systems. Requires multi-processor or multi-core systems
Type for effective execution.
Example Running a word processor and a media player on Running different processes on separate cores
a single-core processor. in a multi-core CPU.

Multiprogramming improves CPU utilization by having multiple programs in memory, switching between them as
necessary, while multiprocessing leverages multiple CPUs to handle tasks in parallel, enhancing both speed and
efficiency.

Ques 15. Differentiate Between Kernel Level and User Level Threads?

ANSWER:

Feature Kernel Level Threads User Level Threads

Execution Managed by the operating system kernel. Managed by user-level libraries,
Control outside of kernel control.
Switching Involves overhead due to context switching in Faster, as it does not require a
kernel mode. switch to kernel mode.
Concurrency True concurrency on multiprocessor systems, as Limited concurrency as all threads
threads can be scheduled on different CPUs are seen as a single process by the
independently. OS.
Portability Less portable across different OS Portable across various operating
implementations. systems.

04811104424 KARTIK KAUSHIK MCA -1 SEM

 System Calls Requires support from the operating system. Does not require OS support, but
cannot make direct system calls.

Kernel-level threads are directly managed by the operating system, which enables true parallelism on multi-core
systems. However, this also results in higher overhead. User-level threads are faster to switch but have limitations in
true parallel execution and are limited by the single process’s view from the OS perspective.

Ques 16. What is Meant by Context Switch?

ANSWER:

A context switch occurs when the CPU shifts from executing one process or thread to another. During this switch,
the operating system saves the current state (context) of the executing process, which includes the program
counter, CPU registers, and other essential data, so the process can resume from the same point later. The CPU then
loads the saved state of the next process to be executed. While context switching allows the OS to achieve
multitasking and efficient CPU utilization, it also incurs overhead, as the saving and restoring process takes time and
does not perform any useful computation.

Ques 17. What is the Use of fork() and exec() System Calls?

ANSWER:

• fork(): The fork() system call is used to create a new process, known as the child process, which is a duplicate
of the calling (parent) process. After a successful fork(), two processes run concurrently, sharing the same
code segment but with separate data. This system call is essential for multitasking in Unix-based systems, as
it enables the execution of multiple processes.
• exec(): The exec() system call replaces the memory space of the current process with a new program. When
exec() is called, the current process image is completely replaced by the new program’s image. Typically,
exec() is used after fork() to run a different program in the child process without affecting the parent
process’s execution. This pair of calls (fork() and exec()) allows one process to create another and run a new
program within it.

Ques 18. Differentiate Between Pre-emptive and Non-Pre-emptive Scheduling?

ANSWER:

Feature Pre-emptive Scheduling Non-Pre-emptive Scheduling

Control The OS can interrupt and switch between A process keeps control of the CPU until it
processes. completes or enters a waiting state.
Response Time Generally faster, as processes are frequently Slower response, as higher-priority
switched, ensuring quick response for higher- processes may need to wait for the current
priority tasks. process to finish.
Implementation More complex, requiring a mechanism to Simpler, as no forced context switches are
handle context switching and process control. required.
Examples Round Robin, Shortest Remaining Time First First-Come-First-Served, Shortest Job First

Pre-emptive scheduling is suitable for real-time and interactive systems where quick responses are necessary, while
non-preemptive scheduling is ideal for batch systems, where tasks can run to completion without interruption.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 19. Differentiate Between Long-Term and Short-Term Scheduler?

ANSWER:

Feature Long-Term Scheduler Short-Term Scheduler

Purpose Controls the degree of multiprogramming by deciding Determines which process in the ready
which processes to admit to the system. queue will run next on the CPU.
Frequency Runs less frequently, typically when new jobs arrive in Runs frequently as it manages CPU time
the system. allocation.
Objective Maximizes system throughput by controlling job Maximizes CPU utilization and minimizes
admission. response time.
System More common in batch systems to manage job load. Essential in time-sharing and
Type multitasking systems.

The long-term scheduler regulates which processes are loaded into memory, managing overall system load, while
the short-term scheduler allocates CPU time, aiming to balance CPU utilization and responsiveness.

Ques 20. How Do Distributed Operating Systems Differ from Multiprogrammed and Time-Shared Operating
Systems? Give Key Features of Each.

ANSWER: Distributed Operating Systems

• Definition: A distributed operating system manages a network of independent computers and presents
them as a unified system to users. It enables the sharing of resources like files, printers, and processing
power across multiple locations.
• Key Features:
o Transparency: Provides users with a seamless experience of a single system despite the physical
distribution of resources.
o Resource Sharing: Enables efficient resource utilization by allowing shared access across systems.
o Fault Tolerance: Ensures system reliability and availability through redundancy.
o Scalability: Can expand the system by adding more nodes to the network without significant
reconfiguration.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Multiprogrammed Operating Systems

• Definition: These systems allow multiple programs to reside in memory simultaneously, interleaving their
execution to make better use of CPU time.
• Key Features:
o CPU Utilization: Maximizes the efficiency of the CPU by switching between tasks.
o Task Switching: Quickly switches between programs, reducing idle CPU time.
o Batch Processing: Suited for batch jobs, where multiple tasks are processed without interaction.

Time-Shared Operating Systems

• Definition: A time-shared OS allows multiple users to interact with the system simultaneously, giving each
user the impression of having dedicated access.
• Key Features:
o Time-Slicing: Allocates CPU time in small intervals to multiple users or tasks.
o Interactive Environment: Designed for responsiveness, allowing users to execute commands and
receive feedback quickly.
o Fair Allocation: Ensures fair CPU access among all active users, enabling effective multitasking.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 21. Explain the Following:

ANSWER:

(i) Multitasking System

A multitasking system is an operating system that allows multiple tasks (processes) to run concurrently by rapidly
switching between them. This switching gives the appearance that all tasks are executing simultaneously, though, in
reality, only one task is executed at any given moment. This system is essential for making effective use of the CPU,
ensuring no resource is idle when it could be working on another task. Benefits of multitasking include:

• Efficient Resource Utilization: Multitasking keeps the CPU and other resources occupied by assigning tasks
whenever possible.
• Responsive User Interaction: Multitasking supports running background processes while handling active
user applications.

There are two main types of multitasking:

• Preemptive Multitasking: The OS has control over task scheduling, forcing a task to yield after a set amount
of time (called a time slice). This prevents a single process from monopolizing the CPU.
• Cooperative Multitasking: Each process voluntarily releases control of the CPU, allowing the OS to switch
tasks. This model depends on well-behaved processes and is less efficient when processes are not
cooperative.

(ii) Real-Time System

A real-time system is designed to respond to inputs or events within strict time constraints, known as deadlines. In
such systems, timing is as crucial as logical correctness, as any missed deadline could lead to critical failures. Real-
time systems are divided into:

• Hard Real-Time Systems: These systems require absolute adherence to deadlines, with any delay potentially
causing catastrophic results. Examples include pacemakers, industrial control systems, and flight navigation.
• Soft Real-Time Systems: Deadlines are important, but missing one occasionally is acceptable without causing
severe issues. Examples include multimedia streaming, online gaming, and stock trading systems.

Real-time systems prioritize quick processing and predictable response times. They are built for reliability and
accuracy in time-critical operations and often use specialized hardware and software to meet these constraints.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 22. What is Semaphore? Explain Busy-Waiting Semaphores.

ANSWER:

A semaphore is a synchronization tool used in concurrent programming to control access to shared resources by
multiple processes or threads. It helps prevent race conditions and ensures that only a specified number of
processes can access a shared resource simultaneously. Semaphores operate on two basic atomic operations:

• Wait (P): Decrements the semaphore value. If the semaphore value is less than or equal to zero, the process
waits until the semaphore is greater than zero.
• Signal (V): Increments the semaphore value, potentially releasing a waiting process.

Types of Semaphores:

• Binary Semaphore: Also called a mutex, it only has values 0 or 1, indicating whether a resource is available
(1) or locked (0).
• Counting Semaphore: Can take any integer value, typically used when multiple instances of a resource are
available (e.g., a pool of printers).

Busy-Waiting Semaphores: Busy waiting occurs when a process repeatedly checks the semaphore in a loop
(spinlock) while waiting to acquire the resource. While this approach ensures quick access once the resource
becomes available, it consumes CPU time inefficiently as it constantly checks the semaphore state. Busy waiting is
commonly used in systems where the wait time is short and system efficiency is less of a concern. However, in
multiprocessor systems, busy waiting can improve performance due to reduced overhead in process switching.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 23. Explain the Differences Between Multilevel Queue and Multilevel Feedback Queue Scheduling (with
Diagram and Table).

ANSWER:

Multilevel Queue Scheduling and Multilevel Feedback Queue Scheduling are two process-scheduling algorithms
designed to organize and prioritize tasks efficiently. Here’s an explanation of each along with a comparison in tabular
format.

Multilevel Queue Scheduling

• Definition: Multilevel Queue Scheduling divides processes into separate queues based on characteristics
such as priority, type, or expected response time.
• Characteristics:
o Each queue is permanently assigned a priority level, and higher-priority queues are processed first.
o Different scheduling algorithms can be assigned to different queues; for instance, high-priority
queues might use Round Robin, while low-priority ones use First Come, First Served (FCFS).
o Processes stay in the same queue throughout their lifecycle, which limits flexibility.

Multilevel Feedback Queue Scheduling

• Definition: In Multilevel Feedback Queue Scheduling, processes are allowed to move between queues based
on their behavior and CPU usage. This system adapts to process needs and provides a more flexible
structure.
• Characteristics:
o Processes can move to higher or lower priority queues based on their CPU burst characteristics or
time spent waiting, ensuring fair access.
o This flexibility allows the algorithm to prioritize short tasks, interactive processes, and I/O-bound
jobs.
o Each queue can use a different scheduling method, and the feedback structure helps prevent
starvation of low-priority processes.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Comparison Table: Multilevel Queue vs. Multilevel Feedback Queue Scheduling

Feature Multilevel Queue Scheduling Multilevel Feedback Queue Scheduling

Queue Structure Fixed queues; processes remain in the Dynamic queues; processes can move between
same queue queues
Process Movement No movement between queues Processes can change queues based on priority
adjustments
Scheduling Flexibility Rigid; fixed queues make it less flexible Flexible; adapts to process needs and CPU usage
Starvation Starvation may occur for low-priority Lower risk of starvation due to queue feedback
Prevention processes mechanism
Application Suitable for systems with distinct Suitable for general-purpose systems requiring
process categories adaptability
Scheduling Each queue has its own static Queues may have different algorithms and
Algorithm scheduling algorithm feedback adjustments
Examples of Queue System, Interactive, Batch, etc. Levels based on CPU bursts, priority, or
Levels user/system process

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 24. How Do Semaphores Help in Process Synchronization? What is the Difference Between Binary and
Counting Semaphores?

ANSWER:

Semaphores are synchronization tools used in operating systems to manage concurrent processes accessing shared
resources. They help prevent race conditions by ensuring that only a specific number of processes can access a
critical section or resource at any given time.

Semaphores operate based on two atomic operations:

1. Wait (P): Decreases the semaphore’s count. If the count becomes less than zero, the process waits until the
semaphore is positive.
2. Signal (V): Increases the semaphore’s count, potentially allowing a waiting process to enter the critical
section.

By controlling access to shared resources, semaphores ensure:

• Mutual Exclusion: Only one process (in binary semaphore cases) or a specific number of processes (in
counting semaphore cases) can access the resource simultaneously.
• Orderly Process Synchronization: Processes are controlled in an orderly manner to prevent issues such as
race conditions.

Difference Between Binary and Counting Semaphores

Feature Binary Semaphore Counting Semaphore

Definition A semaphore that takes only two values, 0 A semaphore that can take any integer
and 1. value.
Functionality Used for mutual exclusion; only one process Used to manage access for multiple
can access the resource at a time. instances of a resource.
Values 0 (locked) and 1 (unlocked). Any non-negative integer, representing
available resources.
Use Cases Suitable for exclusive access scenarios, like Suitable for counting the availability of
managing a critical section. limited resources, like a pool of printers.
Example Mutex locks where only one thread/process Semaphore counters for multiple instances
can access a resource at a time. of shared resources.
Implementation Simple to implement; often built into OS- Requires tracking and updating counts for
Complexity level locks. each access.
Efficiency Very efficient for single-resource access Effective for managing multiple resources
control. or resource pools.

Explanation with Examples

• Binary Semaphore (Mutex):

o Example: Mutex locks control access to a single resource, allowing only one thread or process to
access a critical section at a time.
o Operation: The semaphore value is set to 1 when the resource is free. When a process wants to
access the resource, it uses wait to decrease the value to 0, indicating that the resource is now in
use. Once done, it calls signal to set the value back to 1, freeing the resource.
• Counting Semaphore:
o Example: Managing a printer pool where there are multiple printers (resources) available. The
semaphore count is initialized to the number of available printers.
o Operation: When a process wants to use a printer, it calls wait to decrease the count by 1. After
using the printer, it calls signal to increase the count by 1, indicating the printer is free again.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 25. Write Three Differences Between a Process and a Thread. What Do You Mean by User-Level and Kernel-
Level Threads? Write Any Three Differences Among Them.

ANSWER:

Processes and Threads are fundamental units of execution in an operating system. While they share some
similarities, they differ significantly in how they manage resources, memory, and scheduling. Additionally, threads
can be further categorized into User-Level Threads and Kernel-Level Threads, each with distinct characteristics.

Differences Between Process and Thread

Feature Process Thread

Definition An independent execution unit with its own A lightweight execution unit within a process
memory and resources. that shares memory and resources.
Memory Has separate memory space, including code, Shares the memory and resources of the
data, and stack segments. process it belongs to.
Communication Inter-process communication (IPC) is needed, Threads within the same process can
making it slower and more complex. communicate directly through shared
memory.
Overhead Higher overhead due to separate memory Lower overhead as threads share memory
allocation and management. within the same process.
Creation More time-consuming to create and manage. Faster and more efficient to create and
manage.

Explanation of User-Level Threads vs. Kernel-Level Threads

• User-Level Threads: Managed by user-level libraries rather than directly by the OS. These threads are
lightweight and fast to switch but may lack system-level integration, as the OS treats them as a single
process.
• Kernel-Level Threads: Managed directly by the operating system kernel. They allow more direct interaction
with OS resources and system scheduling but are generally slower due to kernel overhead.

Differences Between User-Level Threads and Kernel-Level Threads

Feature User-Level Threads Kernel-Level Threads

Management Managed by user libraries (not directly by OS). Managed by the OS kernel.
Scheduling Scheduling is done by the user-level library, making Scheduled by the OS, enabling better
it faster but less integrated with the OS. system-level integration and control.
System Calls Cannot take advantage of multi-core systems Can make use of multiple cores, allowing
directly, as they are seen as a single process by the concurrent execution at the OS level.
OS.
Switching Faster, as switching between threads doesn’t Slower, as switching requires kernel
Speed involve kernel calls. intervention, adding overhead.
Example Java Virtual Machine (JVM) threads in some Linux threads (e.g., POSIX threads).
environments.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 26. Design a Solution to a Critical Section Problem Using One Semaphore and Check it for Mutual Exclusion,
Progress, and Bounded Waiting Conditions?

ANSWER:

The Critical Section Problem arises in concurrent programming when multiple processes or threads access a shared
resource simultaneously. To solve this problem, synchronization is required to ensure that only one process enters
the critical section at a time, and no two processes access shared resources simultaneously in an unsafe way.

Solution Using Semaphore

A semaphore is a synchronization primitive used to control access to shared resources by multiple processes in a
concurrent system. It can be used to solve the critical section problem by using a binary semaphore (also called a
mutex) to lock and unlock the critical section.

Here’s how the solution works:

1. Initialize the Semaphore: We create a binary semaphore, typically initialized to 1, which represents that the
critical section is available. The value 1 indicates that no process is currently in the critical section, while 0
means it is occupied.
2. Enter the Critical Section:
o Each process that wants to enter the critical section will first check the semaphore.
o It performs a wait (P) operation (e.g., P(semaphore)) to decrement the semaphore value.
o If the semaphore value is 1, it will be set to 0, and the process will be allowed to enter the critical
section.
o If the value is already 0, the process will wait until the semaphore becomes 1, indicating that
another process has exited the critical section.
3. Exit the Critical Section:
o After completing its operations within the critical section, the process performs a signal (V)
operation (e.g., V(semaphore)).
o This increments the semaphore value back to 1, signaling that the critical section is now available for
other processes to enter.

Pseudocode Solution

Here’s the pseudocode for the critical section solution using a binary semaphore.

// Initialize the semaphore

semaphore mutex = 1; // binary semaphore with initial value 1

// Process code for entering and exiting critical section

while (true) {
// Wait (P) operation
wait(mutex); // decrement the semaphore

// Critical Section
// (Only one process can execute this part at a time)

// Signal (V) operation

signal(mutex); // increment the semaphore

// Remainder Section
}

Explanation of the Solution with Conditions

04811104424 KARTIK KAUSHIK MCA -1 SEM

The solution must satisfy three primary conditions for the critical section problem: Mutual Exclusion, Progress, and
Bounded Waiting.

1. Mutual Exclusion:
o Mutual exclusion means that only one process can enter the critical section at a time.
o In this solution, the wait(mutex) operation ensures mutual exclusion. When a process enters the
critical section, it sets mutex to 0, blocking other processes from entering until it exits.
o Once the process exits, it increments mutex to 1 through the signal(mutex) operation, allowing other
processes to enter.
2. Progress:
o The progress condition ensures that if no process is in the critical section, the decision of which
process will enter next depends on the waiting processes.
o In this solution, processes outside the critical section cannot block others from entering. If a process
finishes its work in the critical section, it signals (increments) the semaphore, allowing other
processes to make progress.
3. Bounded Waiting:
o Bounded waiting prevents indefinite delays for processes waiting to enter the critical section.
o While basic semaphores do not enforce strict bounded waiting, additional logic (such as queuing
waiting processes) could be implemented to satisfy this requirement.
o This solution is fair, as every waiting process will get a chance to enter the critical section in a finite
amount of time.

Example of Process Execution

Suppose we have two processes, P1 and P2, that both need to access a shared resource:

1. Initial State: mutex = 1

2. Process P1: Executes wait(mutex) and decrements mutex to 0. P1 enters the critical section.
3. Process P2: Attempts to execute wait(mutex), but since mutex = 0, it waits.
4. Process P1: Completes its critical section and executes signal(mutex), incrementing mutex to 1.
5. Process P2: Now finds mutex = 1, so it can enter the critical section.

Advantages of the Semaphore Solution

• Simplicity: Using a single semaphore simplifies managing access to the critical section.
• Efficiency: This solution provides mutual exclusion with minimal overhead.
• Flexibility: Semaphores can be applied to both single and multiple shared resource scenarios.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 27. Write a Solution to Readers-Writers Problem Using Semaphore and Justify Its Working.

ANSWER:

The readers-writers problem is a classic synchronization problem, where multiple readers can access a shared
resource simultaneously, but only one writer should access it at any time. Here’s a solution using semaphores:

Semaphore mutex = 1; // Controls access to the read_count variable.

Semaphore wrt = 1; // Controls access to the shared resource.
int read_count = 0;

void reader() {
wait(mutex); // Protecting access to read_count
read_count++;
if (read_count == 1) {
wait(wrt); // First reader locks out writers
}
signal(mutex);

// Reading section

wait(mutex);
read_count--;
if (read_count == 0) {
signal(wrt); // Last reader releases the lock
}
signal(mutex);
}

void writer() {
wait(wrt); // Writers gain exclusive access to the resource
// Writing section
signal(wrt); // Writer releases lock after writing
}

• Justification:
o Multiple readers can read concurrently if no writers are present.
o Only one writer can write to the resource, ensuring data consistency.
o Prevents race conditions on read_count with the mutex semaphore.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 28. Main Features of the Linux Operating System.

ANSWER:

The Linux Operating System is an open-source, Unix-like operating system known for its flexibility, security, and
customization. Developed by Linus Torvalds in 1991, Linux has grown into a highly versatile OS, powering everything
from personal computers to servers and embedded systems.

1. Open Source and Free

• Linux is distributed under the GNU General Public License (GPL), meaning the source code is freely available
to anyone.
• Users can modify, distribute, and use Linux without licensing fees, making it a popular choice for individuals
and organizations worldwide.

2. Multitasking and Multiuser Capabilities

• Multitasking: Linux allows multiple processes to run simultaneously, making it ideal for complex and
intensive computing tasks.
• Multiuser: Multiple users can access the system at the same time without interfering with each other,
making it suitable for server environments and shared systems.

3. Security and Permissions

• Linux provides robust security through user accounts, permissions, and roles.
• The OS uses permission modes (read, write, execute) to protect files and directories, making it more
resistant to unauthorized access and malware.

4. File System Management

• Linux supports multiple file systems, including EXT3, EXT4, XFS, Btrfs, and NTFS.
• It organizes data hierarchically and uses a virtual file system (VFS) layer to interact with various physical file
systems, allowing compatibility and flexibility.

5. Portability and Compatibility

• Linux can run on various hardware platforms, including x86, ARM, and RISC, making it a highly portable OS.
• Linux is compatible with numerous devices and software, providing support for a wide range of peripherals,
drivers, and applications.

6. Kernel Independence and Modularity

• The Linux kernel is monolithic but modular, allowing users to add or remove features without modifying the
kernel itself.
• This modular design enables users to load only the required components, optimizing performance.

7. Shell and Command-Line Interface

• Linux provides powerful command-line interfaces (CLI) such as Bash, Zsh, and Fish, enabling users to
perform tasks efficiently.
• Users can automate tasks, manage system processes, and perform complex operations through scripting.

8. Process and Memory Management

• Linux provides efficient process scheduling through algorithms such as CFS (Completely Fair Scheduler).

04811104424 KARTIK KAUSHIK MCA -1 SEM

 • Memory management techniques, like virtual memory and paging, optimize resource use and prevent
memory leaks.

9. Networking Capabilities

• Linux includes strong networking features, supporting TCP/IP protocols and enabling services like DNS, FTP,
and HTTP.
• Many web servers, cloud platforms, and internet services are built on Linux due to its reliability and
scalability in networking.

10. Support for Development and Customization

• Linux is a favorite among developers due to its extensive support for programming languages, libraries, and
tools.
• Users can customize the kernel and modify distributions, creating tailored versions for specific needs.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 29. Difference Between Many-to-Many and One-to-One Thread Models.

ANSWER:

In operating systems, threads enable concurrent task execution within a process. Different threading models
manage the relationship between user threads (managed by application) and kernel threads (managed by OS).
Many-to-Many and One-to-One are two key threading models with distinct characteristics.

One-to-One Thread Model

1. Definition: In the One-to-One model, each user-level thread has a corresponding kernel-level thread.
2. Characteristics:
o Each user thread is mapped directly to a kernel thread.
o Thread operations such as creation, termination, and switching are managed by the OS, giving fine-
grained control over each thread.
3. Advantages:
o Allows true parallelism on multi-core systems, as each thread can run on a separate processor.
o Threads can take advantage of kernel-level scheduling and priority mechanisms, improving
performance.
4. Disadvantages:
o High resource usage, as each thread requires a separate kernel-level thread.
o Limited by the OS’s support for kernel threads, potentially impacting performance on systems with
many threads.

Many-to-Many Thread Model

1. Definition: In the Many-to-Many model, multiple user-level threads are mapped onto a smaller or equal
number of kernel threads.
2. Characteristics:
o The OS and runtime library manage the mapping between user and kernel threads, allowing
flexibility.
o User threads do not require a direct kernel thread, reducing resource consumption.
3. Advantages:
o Efficient resource use, as multiple user threads can share fewer kernel threads.
o Allows high concurrency without creating too many kernel threads, optimizing system performance.
4. Disadvantages:
o Context switching between user and kernel threads adds complexity and overhead.
o Limited control over individual thread priorities since several user threads share kernel resources.

Comparison Table:

Feature One-to-One Model Many-to-Many Model

Mapping Each user thread has a corresponding kernel Multiple user threads map to fewer kernel
thread. threads.
Concurrency Allows true parallel execution on multi-core Concurrency is limited by the number of kernel
systems. threads.
Resource High resource usage due to 1:1 mapping. More efficient, as multiple user threads share
Usage fewer kernel threads.
Overhead Higher OS overhead due to frequent kernel Lower OS overhead but requires runtime
calls. management.
Use Cases Ideal for applications needing strong Suitable for applications with high concurrency
parallelism, like data processing. but not necessarily parallelism.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 30. Multilevel Feedback Queue Scheduling.

ANSWER:

Multilevel Feedback Queue (MLFQ) Scheduling is an advanced scheduling algorithm designed to handle processes
with varying priorities dynamically. Unlike traditional scheduling, MLFQ allows processes to change priority based on
their behavior and requirements, balancing CPU-bound and I/O-bound tasks effectively.

How Multilevel Feedback Queue Scheduling Works

1. Multiple Queues with Different Priorities:

o MLFQ uses several queues, each with a distinct priority level.
o High-priority queues are given short time slices, while low-priority queues have longer time slices.
o Processes start in the highest-priority queue and move to lower-priority queues if they consume
their time slice.
2. Dynamic Priority Adjustment:
o A key feature of MLFQ is its feedback mechanism, allowing processes to be re-prioritized based on
their CPU usage.
o CPU-bound processes gradually move to lower-priority queues, while I/O-bound or interactive
processes remain in higher-priority queues.
3. Aging and Promotion:
o To prevent starvation, MLFQ may use aging, gradually increasing the priority of processes that have
been waiting for a long time.
o Processes are promoted back to higher-priority queues if they have not used their allocated time
slice, ensuring responsiveness for interactive tasks.

Advantages of Multilevel Feedback Queue Scheduling

1. Adaptability:
o MLFQ adapts to process behavior, providing high-priority for short, interactive processes and low-
priority for long-running, CPU-bound tasks.
2. Efficient CPU Utilization:
o By allowing CPU-bound processes to move to lower-priority queues, MLFQ improves CPU utilization
while prioritizing interactive processes.
3. Prevention of Starvation:
o With aging mechanisms, MLFQ prevents lower-priority processes from starving, ensuring fair access
to CPU resources over time.

Disadvantages of Multilevel Feedback Queue Scheduling

1. Complex Implementation:
o Managing multiple queues, priority adjustments, and aging can be complex.
2. Unpredictable Response Times:

04811104424 KARTIK KAUSHIK MCA -1 SEM

 o While MLFQ is designed to adapt to process behavior, predicting response times can be challenging,
especially in heavily loaded systems.

Example:

Consider a system with three queues:

• Queue 1 (highest priority): Time slice of 2 ms

• Queue 2 (medium priority): Time slice of 4 ms
• Queue 3 (lowest priority): No time slice (FIFO order)

A new process starts in Queue 1. If it exhausts its time slice, it moves to Queue 2. If it also uses its time slice in Queue
2, it is moved to Queue 3. Processes that use only a portion of their time slice may stay in their current queue or be
promoted.

Ques 31. Job Queue, Ready Queue, and Device Queue in Process Scheduling?

ANSWER:

Job Queue: The job queue is a collection of processes that are waiting to be admitted into the system for execution.
It is essentially a pool of all the processes that are in the system but are not yet in the ready state. When processes
are submitted to the operating system (OS), they are initially placed in the job queue, waiting for the OS to allocate
resources for their execution. The job queue is where processes wait for admission to the ready queue, where they
can be scheduled for CPU time.

• Functionality: The job queue handles incoming processes that are waiting to be loaded into memory and
executed.
• State: The processes in the job queue are typically in a "new" state.

Ready Queue: The ready queue is a queue that contains all processes that are ready to execute, but waiting for CPU
time. Once a process has been loaded into memory and is ready to execute, it is moved from the job queue to the
ready queue. The processes in the ready queue are in the "ready" state, meaning they are fully prepared to execute
but are waiting for the CPU to become available. The ready queue is typically implemented as a circular queue or a
priority queue.

• Functionality: The ready queue holds processes that are waiting for CPU time to execute. The CPU scheduler
selects processes from this queue for execution.
• State: Processes in this queue are in the "ready" state, meaning they are prepared to run once they get CPU
time.

Device Queue: The device queue contains processes that are waiting for an I/O device, such as a disk, printer, or
network interface. These processes are in the "blocked" state, meaning they cannot continue execution until the
device becomes available. When a process requires a specific device, it is moved from the ready queue to the
appropriate device queue. After the process completes its I/O operation, it is moved back to the ready queue,
provided it has not been blocked by any other conditions.

04811104424 KARTIK KAUSHIK MCA -1 SEM

 • Functionality: The device queue manages processes waiting for I/O operations, ensuring that processes are
scheduled efficiently when a device becomes available.
• State: Processes in this queue are in the "blocked" or "waiting" state because they cannot proceed until the
required device becomes available.

Ques 32. Criteria for CPU Scheduling Algorithms.

ANSWER:

CPU scheduling algorithms are designed to determine the order in which processes should be assigned CPU time to
ensure efficient execution. The various criteria considered in these algorithms are:

1. CPU Utilization: The degree to which the CPU is being used. High CPU utilization is generally desired to keep
the CPU busy.
2. Throughput: The number of processes completed per unit of time. High throughput means that the system
can complete more tasks in a given period.
3. Turnaround Time: The total time taken by a process from submission to completion. It includes waiting,
execution, and I/O times. The goal is to minimize turnaround time.
4. Waiting Time: The amount of time a process spends waiting in the ready queue before it gets executed.
5. Response Time: The time between submitting a request and receiving the first response. This is important in
interactive systems where the user expects prompt feedback.
6. Fairness: Ensuring that every process gets a fair share of CPU time, especially in multi-user systems.

Now, let's dive into the two specific CPU scheduling algorithms:

(i) Shortest Job First (SJF) Scheduling

SJF is a non-preemptive CPU scheduling algorithm that selects the process with the shortest burst time (the next CPU
execution time) to run first. The key idea behind SJF is that processes with shorter execution times should be
executed before those with longer execution times to minimize the average waiting time.

• Preemptive vs Non-Preemptive: The basic version of SJF is non-preemptive, meaning once a process starts
executing, it runs to completion. However, a preemptive version, known as Shortest Remaining Time First
(SRTF), allows processes to be preempted if a new process with a shorter burst time arrives.
• Advantages: SJF minimizes the average waiting time and is optimal in terms of minimizing the average
turnaround time for a set of processes.
• Disadvantages: The major drawback is that it requires knowledge of the process burst time, which may not
always be known. Additionally, it can lead to starvation, as longer processes may never get CPU time if
shorter processes keep arriving.

04811104424 KARTIK KAUSHIK MCA -1 SEM

(ii) Round Robin (RR) Scheduling

Round Robin is one of the simplest and most widely used preemptive CPU scheduling algorithms. In RR, each process
is assigned a fixed time quantum (also called a time slice). When a process is allocated CPU time, it runs for a time
equal to the time quantum or until it finishes execution, whichever comes first. If a process doesn't finish execution
within its time slice, it is preempted, and the next process in the ready queue gets its turn.

• Time Quantum: The time quantum is a critical parameter in RR. If the quantum is too large, RR behaves
similarly to First-Come, First-Served (FCFS), and if it's too small, the system might incur high context-
switching overhead.
• Advantages: RR is simple to implement and fair, as every process gets an equal share of CPU time. It is well-
suited for time-sharing systems where processes are expected to interact with users.
• Disadvantages: RR can result in higher turnaround times if the time quantum is too large, and if it’s too
small, the overhead from frequent context switching can degrade performance.

Ques 33. Semaphores and the Role of wait() and signal()?

ANSWER:

Semaphores are synchronization primitives used to manage concurrent processes in operating systems. A
semaphore is an integer variable used to control access to a shared resource. Semaphores can be classified as binary
(taking values 0 or 1) or counting (taking non-negative integer values).

• Functionality: Semaphores are used to signal and wait for conditions to be met, allowing processes to
coordinate their actions and avoid race conditions or deadlocks.
• Types:
o Binary Semaphores (or mutexes): Used to represent a lock, allowing only one process to access a
critical section at a time.
o Counting Semaphores: Used when multiple instances of a resource are available, and the
semaphore keeps track of the number of available resources.

The two primary operations used with semaphores are wait() and signal().

• wait() (also known as P or down operation): The wait() function decrements the semaphore value. If the
semaphore value is positive, the process continues; if it is zero, the process is blocked until the semaphore
becomes positive again. Essentially, wait() checks whether a resource is available and blocks the process if
not.
o Syntax: wait(semaphore).
o Effect: Decrements the semaphore value and, if the value is negative, blocks the process until it
becomes positive.
• signal() (also known as V or up operation): The signal() function increments the semaphore value. If any
processes are waiting on the semaphore, one of them is allowed to proceed by being unblocked. It
essentially signals that a resource has been released or that a condition is now true.

04811104424 KARTIK KAUSHIK MCA -1 SEM

 o Syntax: signal(semaphore).
o Effect: Increments the semaphore value, and if any processes are blocked, one of them is allowed to
proceed.

Together, wait() and signal() help manage mutual exclusion, process synchronization, and coordination in concurrent
systems.

Ques 34. Function of the Ready Queue?

ANSWER:

The ready queue plays a critical role in the operating system's scheduling of processes. It is a queue where processes
wait for CPU time after they have been loaded into memory and are ready to execute.

• Functionality: The ready queue holds processes that are in the "ready" state and waiting for CPU time. The
CPU scheduler selects processes from the ready queue to execute based on a scheduling algorithm.
• Process Lifecycle: When a process is created, it starts in the job queue. Once it is loaded into memory and is
ready to execute, it is moved to the ready queue. The CPU scheduler selects processes from the ready queue
to run on the CPU.
• Organization: The ready queue can be organized in various ways depending on the CPU scheduling algorithm
being used. It may be a simple FIFO queue (First-Come, First-Served), a priority queue, or a more complex
structure such as a multi-level feedback queue.
• Preemptive Scheduling: In preemptive scheduling systems, when a higher-priority process arrives, a process
in the ready queue may be preempted and moved back to the queue to allow the higher-priority process to
run.
• Role in Scheduling: The ready queue helps ensure that processes are given CPU time in an orderly manner. It
is crucial in multi-tasking systems where multiple processes are waiting to run. Efficient management of the
ready queue ensures fair CPU allocation and minimizes waiting times for processes.

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 35. Process P1, P2 and P3 arrive for execution at times indicated. Using non-pre-emptive scheduling, answer
the questions below:

(i) What is the average turnaround time for these processes with FCFS scheduling?
(ii) What is the average turnaround time for these processes with SJF scheduling?
(iii) What is the average turnaround time if the CPU is left idle for first 1 unit and then SJF scheduling is
used?

ANSWER:

1. First-Come, First-Serve (FCFS) Scheduling

In FCFS scheduling, processes are executed in the order of their arrival times. The turnaround time for each process
is calculated as:

Turnaround Time=Completion Time−Arrival Time

Execution Order (FCFS):

1. P1 arrives at 0.0 and is executed first with a burst time of 8.

o Completion Time for P1 = 0.0 + 8 = 8.0
2. P2 arrives at 0.4, but P1 is still running, so P2 starts after P1 finishes.
o Start Time for P2 = 8.0
o Completion Time for P2 = 8.0 + 4 = 12.0
3. P3 arrives at 0.8 but has to wait until P2 completes.
o Start Time for P3 = 12.0
o Completion Time for P3 = 12.0 + 1 = 13.0

Turnaround Times (FCFS):

• P1: 8.0−0.0=8.08.0 - 0.0 = 8.08.0−0.0=8.0

• P2: 12.0−0.4=11.612.0 - 0.4 = 11.612.0−0.4=11.6
• P3: 13.0−0.8=12.213.0 - 0.8 = 12.213.0−0.8=12.2

Average Turnaround Time (FCFS):

8.0+11.6+12.23 / 3 =31.83/3 =10.6

2. Shortest Job First (SJF) Scheduling (Non-preemptive)

In SJF, the process with the shortest burst time is executed next, based on the available processes when the CPU is
free.

Execution Order (SJF):

1. P1 starts first at 0.0 with a burst time of 8.

o Completion Time for P1 = 0.0 + 8 = 8.0
2. At t = 8.0, both P2 and P3 are available, and P3 has the shorter burst time (1 vs. 4).
o Start Time for P3 = 8.0
o Completion Time for P3 = 8.0 + 1 = 9.0

04811104424 KARTIK KAUSHIK MCA -1 SEM

 3. P2 starts after P3 completes.
o Start Time for P2 = 9.0
o Completion Time for P2 = 9.0 + 4 = 13.0

Turnaround Times (SJF):

• P1: 8.0−0.0=8.08.0 - 0.0 = 8.08.0−0.0=8.0

• P2: 13.0−0.4=12.613.0 - 0.4 = 12.613.0−0.4=12.6
• P3: 9.0−0.8=8.29.0 - 0.8 = 8.29.0−0.8=8.2

Average Turnaround Time (SJF):

8.0+12.6+8.23/3 =28.83/3 =9.6

3. CPU Idle for 1 Time Unit, then SJF Scheduling

If the CPU remains idle for the first 1 unit of time, we start scheduling only at t = 1.

Execution Order (Idle then SJF):

1. At t = 1, all three processes (P1, P2, and P3) have arrived.

o P3 has the shortest burst time, so it is executed first.
o Start Time for P3 = 1.0
o Completion Time for P3 = 1.0 + 1 = 2.0
2. After P3 completes, P2 has the next shortest burst time.
o Start Time for P2 = 2.0
o Completion Time for P2 = 2.0 + 4 = 6.0
3. Finally, P1 starts after P2 completes.
o Start Time for P1 = 6.0
o Completion Time for P1 = 6.0 + 8 = 14.0

Turnaround Times (Idle + SJF):

• P1: 14.0−0.0=14.014.0 - 0.0 = 14.014.0−0.0=14.0

• P2: 6.0−0.4=5.66.0 - 0.4 = 5.66.0−0.4=5.6
• P3: 2.0−0.8=1.22.0 - 0.8 = 1.22.0−0.8=1.2

Average Turnaround Time (Idle + SJF):

14.0+5.6+1.23/3 =20.83/3 =6.93

Summary of Results

1. Average Turnaround Time (FCFS): 10.6

2. Average Turnaround Time (SJF): 9.6
3. Average Turnaround Time (Idle + SJF): 6.93

04811104424 KARTIK KAUSHIK MCA -1 SEM

Ques 36. Given the following set of processes along with their data. Compute average waiting times for pre-
emptive SJF and Round Robin scheduling algorithms for each process.

Assume context switching overhead is 1 time unit and time quantum used in round robin scheduling is 2 times
units.

Preemptive SJF Scheduling

In Preemptive SJF (also known as Shortest Remaining Time First), we always select the process with the shortest
remaining burst time when the CPU becomes available. We also add 1 unit of time for each context switch.

1. Calculate Execution Timeline for Preemptive SJF

Let's go through each process selection step-by-step to build a timeline with context switches:

o Time 0: P1 starts (remaining burst time = 8)

o Time 1: P2 arrives with a burst time of 5, but P1 continues since it has less remaining time (7)
o Time 2: P3 and P4 arrive. P3 (remaining time 2) has the shortest remaining time.
▪ Context switch to P3 (time = 3, P1 paused with 7 remaining)
o Time 3-4: P3 completes its burst (time = 4)
o Time 4: The remaining times for processes are: P1 = 7, P2 = 5, P4 = 4
▪ P4 has the shortest time; context switch to P4 (time = 5)
o Time 5-8: P4 executes and finishes at time = 8
o Time 8: Remaining: P1 = 7, P2 = 5
▪ P2 has the shortest remaining time; context switch to P2 (time = 9)
o Time 9-13: P2 executes and completes at time = 13
o Time 13: P1 (remaining 7) resumes and completes execution by time = 20

2. Calculate Waiting Time for Each Process (Preemptive SJF)

The waiting time for each process is calculated as:

Waiting Time=Start Time−Arrival Time+Waiting in Queue\text{Waiting Time} = \text{Start Time} - \text{Arrival Time}
+ \text{Waiting in Queue}Waiting Time=Start Time−Arrival Time+Waiting in Queue

Calculations give:

o P1 Waiting Time: 6 units

o P2 Waiting Time: 7 units
o P3 Waiting Time: 1 unit
o P4 Waiting Time: 2 units

Round Robin Scheduling (Time Quantum = 2)

With Round Robin, we rotate through the processes in order, using a time quantum of 2 units per process and
adding 1 unit for each context switch.

04811104424 KARTIK KAUSHIK MCA -1 SEM

 1. Calculate Execution Timeline for Round Robin

Following each process in sequence:

o Time 0: P1 starts (executes 2 units)

▪ Context switch (time = 3)
o Time 3: P2 starts (executes 2 units)
▪ Context switch (time = 6)
o Time 6: P3 starts (executes 2 units and completes)
▪ Context switch (time = 9)
o Time 9: P4 starts (executes 2 units)
▪ Context switch (time = 12)
o Continue rotating with 2 units per process until each completes.
2. Calculate Waiting Time for Each Process (Round Robin)

Following the rotation, we get:

o P1 Waiting Time: 10 units

o P2 Waiting Time: 8 units
o P3 Waiting Time: 4 units
o P4 Waiting Time: 7 units

Summary of Results

1. Average Waiting Time (Preemptive SJF): 4.0

2. Average Waiting Time (Round Robin): 7.25

04811104424 KARTIK KAUSHIK MCA -1 SEM