SET - 1

1. a. Discuss different architectures of Operating System.

b. What is VMware? Write a short note on it.

Ans:- a. Operating System Architectures:

There are several different architectures of operating systems, each designed
to fulfill specific requirements and serve different purposes. Here are a few
common operating system architectures:

1. Monolithic Architecture: In a monolithic architecture, the entire operating

system is contained in a single, large executable file. It includes the kernel,
device drivers, file system, and other components. This architecture is
straightforward but lacks modularity, making it challenging to maintain and
extend.

2. Layered Architecture: The layered architecture divides the operating system

into layers, where each layer provides specific functionality. The lower layers
interact directly with hardware, while higher layers provide services to
applications. This architecture offers better modularity, as each layer can be
developed and modified independently. However, communication between
layers can introduce overhead.

3. Microkernel Architecture: The microkernel architecture aims to minimize the

kernel's functionality and move most services into user-space processes
called servers. The microkernel provides essential services like memory
management and inter-process communication. This architecture offers
improved modularity, reliability, and extensibility, but it incurs additional
overhead due to message passing between processes.

4. Virtual Machine Architecture: In this architecture, a virtual machine monitor

or hypervisor creates virtual machines (VMs) that run multiple operating
systems simultaneously. Each VM operates independently and is isolated from
other VMs. The hypervisor manages the allocation of resources and provides
virtualization of hardware. Virtual machine architectures offer flexibility, better
resource utilization, and isolation.

5. Client-Server Architecture: In a client-server architecture, the operating

system is divided into two parts: the client, which runs on the user's machine,
and the server, which provides services to the clients. The client requests
services from the server, which processes the requests and returns the
results. This architecture is commonly used in networked environments.

b. VMware:
VMware is a software company that provides virtualization and cloud
computing solutions. It offers a range of products, including the VMware
vSphere suite, which enables organizations to create and manage virtualized
environments. Here's a short note on VMware:

VMware's virtualization technology allows multiple virtual machines to run

simultaneously on a single physical server. Each virtual machine operates
independently, with its own operating system and applications. VMware
provides a hypervisor, called VMware ESXi, which sits between the physical
server's hardware and the virtual machines.

Key features and benefits of VMware include:

1. Server Consolidation: VMware enables organizations to consolidate

multiple physical servers into a single server running multiple virtual machines.
This reduces hardware costs, improves resource utilization, and simplifies
management.

2. Resource Allocation and Management: VMware allows administrators to

allocate resources, such as CPU, memory, and storage, to virtual machines
dynamically. This flexibility enables efficient utilization of available resources
and ensures optimal performance.

3. High Availability and Fault Tolerance: VMware provides features like

vMotion and Fault Tolerance, which allow virtual machines to be migrated
between physical servers without downtime and provide redundancy in case
of server failures.

4. Disaster Recovery: VMware offers solutions for disaster recovery, allowing

organizations to replicate virtual machines to a remote site for backup and
rapid recovery in case of a disaster.

5. Cloud Computing: VMware's cloud solutions enable organizations to build

private, hybrid, or public cloud environments. This facilitates scalability, agility,
and flexibility in deploying and managing applications.
Overall, VMware's virtualization technology has revolutionized the IT industry,
providing efficient utilization of resources, improved flexibility, and simplified
management of complex environments.

2. Write a detailed note on FCFS, SJF and Priority scheduling

taking suitable examples. What is Preemptive and Non-preemptive
Scheduling?

Ans:- FCFS (First-Come, First-Served) Scheduling:

FCFS scheduling is a non-preemptive scheduling algorithm where the
processes are executed in the order they arrive. The process that arrives
first gets executed first. It follows a simple concept of serving the
processes based on their arrival time.

Example:
Let's consider three processes with their respective arrival times and
burst times:

Process | Arrival Time | Burst Time

-----------------------------------
P1 |0 |6
P2 |2 |4
P3 |4 |2

In FCFS scheduling, the processes will be executed in the order they

arrive. Therefore, the execution sequence will be:
P1 -> P2 -> P3

SJF (Shortest Job First) Scheduling:

SJF scheduling is a non-preemptive or preemptive scheduling algorithm
that selects the process with the shortest burst time to execute first. It
aims to minimize the average waiting time by giving priority to the
shortest job.

Example:
Consider the same set of processes as before with their arrival times
and burst times:

Process | Arrival Time | Burst Time

-----------------------------------
P1 |0 |6
P2 |2 |4
P3 |4 |2

For SJF scheduling, the process with the shortest burst time gets
executed first. Therefore, the execution sequence will be:
P1 -> P3 -> P2

Priority Scheduling:
Priority scheduling is a non-preemptive or preemptive scheduling
algorithm where each process is assigned a priority, and the process
with the highest priority gets executed first. The priority can be based on
various factors such as process type, system requirements, or
user-defined priorities.

Example:
Consider the same set of processes with their arrival times, burst times,
and priorities:

Process | Arrival Time | Burst Time | Priority

---------------------------------------------
P1 |0 |6 |2
P2 |2 |4 |1
P3 |4 |2 |3

In priority scheduling, the process with the highest priority is executed

first. If two processes have the same priority, then the FCFS principle is
followed. Therefore, the execution sequence will be:
P2 -> P1 -> P3

Preemptive Scheduling:
Preemptive scheduling is a scheduling technique where the running
process can be interrupted and replaced by a higher-priority process. In
preemptive scheduling, the operating system has the ability to stop a
process, save its state, and start executing another process with a
higher priority. It allows for better response time and ensures that critical
tasks get executed promptly.

Non-preemptive Scheduling:
Non-preemptive scheduling is a scheduling technique where a running
process cannot be interrupted until it completes its execution or blocks
itself. Once a process starts executing, it continues until it finishes or
performs an I/O operation. Non-preemptive scheduling is simpler to
implement but may result in longer response times for high-priority tasks
if a lower-priority task is currently running.

3.Discuss Banker’s algorithm and how to find out if a system is in a

safe state or not?

Ans:- Banker's algorithm is a resource allocation and deadlock

avoidance algorithm used in operating systems. It is designed to
manage resource allocation among multiple processes, ensuring that a
system remains in a safe state and avoids the possibility of deadlock.

The Banker's algorithm works based on the following principles:

1. Each process must declare its maximum resource requirements
before it starts execution.
2. The system keeps track of the total available resources and the
resources currently allocated to each process.
3. Before allocating resources to a process, the system checks if the
allocation will leave the system in a safe state. If so, the resources are
allocated; otherwise, the process must wait.

To determine if a system is in a safe state using the Banker's algorithm,

the following steps are followed:

Step 1: Initialization
 a. Input the maximum resource requirements of each process and the
currently allocated resources for each process.
b. Calculate the total available resources.

Step 2: Calculate the Need matrix

a. Calculate the Need matrix, which represents the maximum
resources a process requires minus the resources it already holds.

Step 3: Initialize the work and finish arrays

a. Initialize the work array to the total available resources.
b. Initialize the finish array to false for each process.

Step 4: Find a safe sequence

a. Search for a process that satisfies the following conditions:
i. Its finish value is false.
ii. Its resource needs can be satisfied with the available resources
(work).
b. If such a process is found, allocate its resources to the process and
update the work array.
c. Mark the process as finished (finish = true) and add it to the safe
sequence.
d. Repeat steps a, b, and c until all processes are marked as finished
or no such process is found.

Step 5: Check the system's safety

a. If all processes are marked as finished, the system is in a safe state,
and the safe sequence is the order in which processes were marked as
finished.
b. If any process remains unfinished after exhausting all possibilities,
the system is in an unsafe state, and deadlock may occur.

By following these steps, the Banker's algorithm ensures that resource

allocation is done in a way that prevents deadlock and maintains system
safety. It avoids resource allocation if it may lead to an unsafe state and
ensures that resources are allocated in a manner that satisfies all
processes' needs.
 SET - 2.

4. a. What is PCB? What information is stored in it?

b. What are monitors? Explain.

Ans:- a. PCB (Process Control Block):

PCB stands for Process Control Block. It is a data structure used by
operating systems to store and manage information about a running
process. Each process in an operating system has a corresponding PCB
that holds important details and provides the necessary information for
the operating system to manage and control the process.

The information stored in a PCB typically includes:

1. Process State: It indicates the current state of the process, such as

running, ready, blocked, or terminated.

2. Process Identifier (PID): A unique identification number assigned to

each process by the operating system.

3. Program Counter (PC): It holds the address of the next instruction to

be executed by the process.

4. CPU Registers: The values of CPU registers, including

general-purpose registers, stack pointer, and program status word.

5. Memory Management Information: Information about the memory

allocated to the process, such as base and limit registers, page tables,
or segment tables.

6. Scheduling Information: Process priority, scheduling parameters, and

any other details needed for process scheduling.

7. I/O Status Information: The list of I/O devices allocated to the process,
I/O requests, and their status.
8. Accounting Information: Resource usage statistics, such as CPU time
consumed, execution time, and I/O time.

9. Interprocess Communication Information: Details related to the

process's communication with other processes, such as message
queues, shared memory segments, or semaphores.

PCBs are crucial for the operating system to manage processes

effectively. They allow the operating system to switch between
processes, allocate resources, track process state, and provide context
switching during multitasking.

b. Monitors:
Monitors are a synchronization construct used in concurrent
programming to manage access to shared resources. They provide a
higher-level abstraction compared to low-level synchronization primitives
like locks or semaphores. Monitors ensure mutual exclusion and allow
controlled access to shared resources to avoid data races and maintain
data integrity.

A monitor consists of the following key elements:

1. Shared Data: The data or resources that need to be protected and

accessed by multiple concurrent processes or threads.

2. Procedures or Methods: The monitor provides a set of procedures or

methods that define the operations that can be performed on the shared
data. These methods are the only way to access the shared resources
within the monitor.

3. Condition Variables: Condition variables are used to manage the

synchronization and coordination of processes or threads within the
monitor. They allow processes to wait until a certain condition is met
before proceeding.

The behavior of a monitor is governed by two fundamental principles:

1. Mutual Exclusion: Only one process or thread can execute a
procedure or method within the monitor at any given time. This ensures
that shared data is accessed in a mutually exclusive manner, preventing
concurrent access and potential data corruption.

2. Condition Synchronization: Processes or threads can wait on

condition variables within the monitor, blocking until a specific condition
is satisfied. They can be signaled or notified by other processes when
the condition they were waiting for becomes true.

Monitors provide an intuitive and structured way to implement

synchronisation and manage shared resources in concurrent
programming. They simplify the development of concurrent programs by
encapsulating synchronisation logic and ensuring the integrity of shared
data.

5.Discuss IPC and critical-section problem along with use of

semaphores.

Ans:- IPC (Interprocess Communication):

IPC, short for Interprocess Communication, refers to the mechanisms
and techniques used for communication and data exchange between
different processes running on the same computer or across different
computers in a networked environment. IPC allows processes to share
information, coordinate their actions, and work together to accomplish
tasks. There are several methods of IPC, including shared memory,
message passing, pipes, sockets, and remote procedure calls.

Critical-Section Problem:
The critical-section problem arises when multiple processes or threads
share a common resource or section of code, and each process needs
exclusive access to that resource to avoid data inconsistency or race
conditions. The critical section is the part of the code where the shared
resource is accessed or modified. The critical-section problem aims to
ensure that processes or threads can execute their critical sections
without interference from other processes.
To address the critical-section problem, the following conditions must be
satisfied:

1. Mutual Exclusion: Only one process can be executing its critical

section at a time. No two processes can be in their critical sections
simultaneously.

2. Progress: If no process is executing its critical section and some

processes are waiting to enter their critical sections, the selection of the
process that will enter the critical section next cannot be postponed
indefinitely.

3. Bounded Waiting: There should be a limit on the number of times

other processes can enter their critical sections after a process has
made a request to enter its critical section.

Use of Semaphores:
Semaphores are synchronization primitives commonly used to solve the
critical-section problem and coordinate access to shared resources.
They can be used to enforce mutual exclusion, ensure progress, and
implement synchronization between processes or threads.

A semaphore is a non-negative integer variable that can be accessed

and modified by the following two atomic operations:

1. Wait (P) Operation: If the value of the semaphore is greater than zero,
it decrements the semaphore value by one and allows the process to
continue its execution. If the value is zero, the process is blocked
(suspended) until another process signals (increments) the semaphore.

2. Signal (V) Operation: It increments the value of the semaphore by

one, thereby releasing a waiting process if there is one. If multiple
processes are waiting, one of them is unblocked and allowed to proceed.

Semaphores can be used to implement mutual exclusion by creating a

semaphore initialized to 1 (binary semaphore). A process must acquire
the semaphore (perform a P operation) before entering its critical section
and release it (perform a V operation) when it exits the critical section.

By using semaphores and following proper synchronization protocols,

processes can coordinate their access to shared resources, enforce
mutual exclusion, and prevent race conditions, ensuring that the
critical-section problem is effectively solved.

6. Explain the different Multiprocessor Interconnections and types

of Multiprocessor Operating Systems.

Ans:- Multiprocessor Interconnections:

Multiprocessor interconnections refer to the ways in which processors in
a multiprocessor system are connected to each other to enable
communication, coordination, and sharing of resources. Various
interconnection topologies exist, each offering different characteristics in
terms of scalability, bandwidth, latency, and fault tolerance. Some
common multiprocessor interconnections include:

1. Bus-Based Interconnection:
In a bus-based interconnection, processors are connected to a shared
bus. The bus acts as a communication medium, allowing processors to
exchange data and access shared memory. However, bus-based
interconnections may suffer from bandwidth limitations and contention as
the number of processors increases.

2. Crossbar Interconnection:
A crossbar interconnection provides a dedicated point-to-point
connection between each pair of processors. It offers high bandwidth
and supports concurrent communication between multiple processors.
Crossbar interconnections are highly scalable but can become complex
and expensive as the number of processors grows.

3. Ring Interconnection:
In a ring interconnection, processors are connected in a circular
manner, forming a closed loop. Each processor passes data to its
adjacent processor until it reaches its destination. Ring interconnections
are simple to implement and scale well with a large number of
processors. However, the communication latency may increase with the
size of the ring.

4. Mesh Interconnection:
In a mesh interconnection, processors are arranged in a
two-dimensional grid-like structure. Each processor is connected to its
neighboring processors, forming a mesh network. Mesh interconnections
are scalable, provide direct links between processors, and can handle
concurrent communication. However, their scalability is limited due to the
fixed grid structure.

5. Hypercube Interconnection:
A hypercube interconnection is based on the concept of n-dimensional
hypercube. Each processor is connected to log₂N neighboring
processors, where N is the total number of processors. Hypercube
interconnections offer high scalability, fault tolerance, and low
communication latency. However, the complexity and wiring
requirements increase as the dimension of the hypercube increases.

Types of Multiprocessor Operating Systems:

Multiprocessor operating systems are specifically designed to manage
and utilize the resources of a multiprocessor system effectively. They
provide mechanisms for process scheduling, synchronization, resource
allocation, and interprocess communication. There are two main types of
multiprocessor operating systems:

1. Symmetric Multiprocessing (SMP) Operating Systems:

SMP operating systems treat all processors in the system as equals.
They provide a single shared memory space accessible by all
processors, allowing processes to be executed on any available
processor. SMP operating systems typically use load balancing
algorithms to distribute the workload evenly among processors.
Examples of SMP operating systems include Linux, Windows
NT/2000/XP, and macOS.
2. Asymmetric Multiprocessing (AMP) Operating Systems:
AMP operating systems designate one processor as the master
processor or the control processor, responsible for managing the system
and distributing tasks to other processors. Each processor in an AMP
system may have its private memory and run its own instance of the
operating system. AMP operating systems are commonly used in
embedded systems and real-time applications, where specific
processors are assigned to handle critical tasks. Examples of AMP
operating systems include VxWorks and QNX.

Both SMP and AMP operating systems provide mechanisms for

interprocess communication, such as message passing and shared
memory, to facilitate coordination and data exchange between
processes running on different processors in the multiprocessor system.