Operating System

Assignment No. 1
1. Define an Operating System and Explain its Primary Purpose

An Operating System (OS) is a complex system software that acts as an intermediary

between the hardware of a computer and the software applications that run on it. The
primary role of an OS is to provide an environment for programs to execute and a means for
users to interact with the computer system. It performs several crucial tasks, such as
managing hardware resources, providing security and access control, and offering user
interfaces.

The primary purposes of an operating system are:

• Resource Management: The OS efficiently manages hardware resources like the CPU,
memory, storage, and I/O devices. It ensures that resources are allocated to different
processes in a way that maximizes overall system performance, fairness, and stability.
It prevents conflicts over shared resources by providing access control and
prioritizing resource allocation based on the needs of various programs.

• Process Management: An OS coordinates the execution of processes. It schedules

tasks for execution, ensuring that processes get adequate CPU time, and manages
multitasking by switching between processes (context switching). Additionally, the
OS manages the creation, termination, and synchronization of processes.

• Memory Management: The OS ensures that programs and processes have access to
memory resources. It allocates and deallocates memory space to processes and
implements virtual memory to make more efficient use of available RAM by
swapping data between disk and memory. It also handles memory fragmentation to
ensure that memory is utilized optimally.

• File System Management: The OS organizes and stores data in the form of files and
directories. It provides mechanisms for reading, writing, and modifying files. It
ensures efficient data storage, access, and retrieval, and also implements access
control to manage user permissions on files and directories.

• Security and Access Control: The OS enforces security policies to ensure that
unauthorized users or malicious programs cannot access or modify system resources.
It provides authentication services (like password verification) and controls user
access to files and resources through user permissions and access control lists (ACLs).

• User Interface: The OS offers a platform for users to interact with the system, either
through a command-line interface (CLI) or graphical user interface (GUI). It allows
users to execute commands, run applications, and manage system settings.
In summary, the operating system is the foundation of a computer's functionality, ensuring
that resources are used efficiently, applications can run effectively, and users can interact
with the system intuitively.

2. List and Briefly Describe Three Types of Operating Systems

Operating systems can be categorized based on their functionality, purpose, and target
environment. The following are three common types of operating systems:

1. Batch Operating System:

• Description: A Batch OS is designed for running tasks or jobs in batches. The key
characteristic of a batch OS is that it does not interact with users directly while
processing tasks. Instead, it collects similar tasks (jobs) and executes them
sequentially in a group, or "batch." The operating system executes the jobs one after
the other, without user input during the execution process. This model was widely
used before interactive systems became common.

• Example: Early mainframe computers used batch processing to run payroll systems,
accounting applications, and scientific computations where user interaction was not
required during the process.

• Advantages: Batch systems are suitable for repetitive, large-volume tasks where user
interaction is not needed. They also help in optimizing the use of computational
resources by running jobs automatically.

2. Time-Sharing Operating System:

• Description: A Time-Sharing OS allows multiple users to access a computer system

simultaneously by allocating each user a small time slice of the processor’s time. The
OS switches between tasks very quickly, giving the illusion that all tasks are running
concurrently. This is often referred to as multitasking. Time-sharing systems allow
multiple users to interact with the system at once, usually through terminals
connected to a central computer.

• Example: UNIX and its derivatives (such as Linux) are classic examples of time-
sharing operating systems. Mainframes in the 1960s and 1970s also used time-
sharing to support multiple users.

• Advantages: Time-sharing systems provide interactive user experiences, as multiple

users can run applications concurrently. It also maximizes system utilization, as the
CPU time is divided among multiple users and tasks.

3. Real-Time Operating System (RTOS):

 • Description: A Real-Time Operating System (RTOS) is designed to guarantee that
specific tasks are completed within a certain time frame. In RTOS, processes are
prioritized based on urgency, and the OS ensures that time-critical operations are
performed within strict deadlines. RTOS are used in embedded systems, robotics,
medical devices, and other applications where delays or failure to meet deadlines
could have severe consequences.

• Example: VxWorks, FreeRTOS, and QNX are widely used RTOS platforms in
embedded systems. For instance, VxWorks is used in aerospace and automotive
applications, where precise timing is critical.

• Advantages: RTOS provide deterministic behavior and low-latency performance,

which is crucial for systems where timing and reliability are essential. This makes
them ideal for mission-critical applications, such as space exploration, medical
equipment, and industrial control systems.

3. Explain Any Three Services Provided by an Operating System to Its Users and
Applications

Operating systems offer various services to users and applications, ensuring the smooth
execution of processes and the efficient utilization of resources. Here are three essential
services provided by an OS:

1. Process Scheduling and Multitasking:

• Description: Process scheduling is a core service provided by the OS. The operating
system manages the execution of processes by allocating CPU time to them. It uses
scheduling algorithms such as First-Come, First-Served (FCFS), Round Robin (RR),
and Shortest Job First (SJF) to decide which process should run next. The OS ensures
that multiple processes can run simultaneously (multitasking), even on a single-core
processor, by rapidly switching between them.

• Benefit: Process scheduling allows efficient multitasking, enabling users to run

multiple applications concurrently. The OS can prioritize critical tasks, ensuring that
high-priority processes receive the necessary CPU time, while less urgent tasks are
deferred.

2. Memory Management:

• Description: Memory management refers to how the OS allocates and deallocates

memory to processes and manages system memory resources. The OS handles both
physical memory (RAM) and virtual memory (using disk space to extend the
apparent amount of memory). It tracks memory usage, ensuring that each process
gets the memory it needs without conflicting with others. The OS also handles
 memory swapping, paging, and segmentation to prevent memory fragmentation and
optimize memory utilization.

• Benefit: Memory management ensures that processes run without interference from
each other and makes efficient use of the available memory. It also allows the system
to run larger programs than the physical RAM would normally support by utilizing
virtual memory.

3. Input/Output (I/O) Services:

• Description: The OS provides a set of I/O services that allow applications to interact
with external devices such as disk drives, printers, keyboards, and displays. The OS
abstracts the hardware and provides a consistent interface to applications for
performing I/O operations. It manages device drivers, handles data transfer, and
provides error handling mechanisms for I/O operations. The OS also supports
buffering and spooling to optimize I/O performance.

• Benefit: The OS ensures smooth and efficient communication between applications

and hardware devices. It simplifies the process for applications to perform I/O
operations by providing common interfaces, thus reducing the complexity of dealing
with different types of hardware.

4. Describe the Following Approaches to OS Structure

Operating systems can be organized and structured in different ways depending on their
design philosophy. Below are several common approaches to OS structure:

a) Simple Structure:

• Description: A simple structure OS has a minimalistic design where the OS functions

are tightly integrated into a single layer. This type of OS typically runs with a
monolithic kernel, where all services (file management, memory management,
process scheduling, etc.) reside in the same module or kernel space. This simplicity
makes the OS easy to implement and understand, but it can be less flexible and
harder to scale or maintain as the system grows.

• Example: MS-DOS is a classic example of a simple structure operating system. It has a

monolithic design where the kernel handles all tasks, from process management to
file systems.

• Advantages: Simple structure OS are fast and require fewer resources, which makes
them suitable for smaller, resource-constrained environments. Their straightforward
design is easy to manage and troubleshoot.

b) Layered Approach:
 • Description: The layered approach to OS design organizes the system into layers,
each responsible for a specific subset of functions. The OS is divided into several
layers, starting with the hardware layer at the bottom and progressing up to the user
interface layer at the top. Each layer interacts only with the layer directly beneath it.
This modular design makes it easier to maintain and modify individual components
without affecting the rest of the system.

• Example: Multics is an example of an OS that uses the layered approach. It was

designed to be highly modular, with each layer responsible for a different set of tasks,
such as process management, memory management, and user interface.

• Advantages: The layered approach enhances maintainability, scalability, and

debugging. It allows different teams to work on separate layers independently,
making it easier to add new functionality or fix bugs in one layer without disrupting
the entire system.

c) Microkernels:

• Description: A microkernel is a minimalistic kernel that provides only the essential

functions needed to manage hardware, such as process scheduling and inter-process
communication (IPC). The rest of the operating system functionality, such as file
systems, device drivers, and networking, is implemented in user space as separate
processes. This modular approach improves system security and stability by reducing
the size and complexity of the kernel.

• Example: MINIX and QNX are examples of operating systems that use microkernel
architecture. In a microkernel system, most of the OS's services run in user space
rather than inside the kernel.

• Advantages: Microkernels provide improved system reliability and security, as most

services run in user space and can be isolated from the core kernel. The system is
also more flexible and can be customized easily by adding or removing components.

d) Modules:

• Description: An OS using the modular approach is designed with a core kernel that
can dynamically load and unload modules to extend its functionality. Each module is
a self-contained unit that handles a specific function, such as file systems, device
drivers, or network protocols. These modules can be loaded at runtime, making the
OS more flexible and adaptable to different hardware configurations and needs.

• Example: Linux is a prime example of an OS that uses a modular approach. It allows

kernel modules to be loaded or unloaded as needed, depending on the hardware
and system requirements.
 • Advantages: The modular approach provides high flexibility and scalability. It allows
for efficient resource usage and enables easy updates or additions of new features
without recompiling the entire kernel.

5. What is a Virtual Machine? Explain Its Benefits

A Virtual Machine (VM) is an emulation of a physical computer that runs on a host system. A
virtual machine operates as though it were a separate, independent machine, but it shares
the resources of the host system. The key feature of VMs is that they allow multiple OS
instances to run simultaneously on the same physical hardware, each with its own
virtualized hardware environment, including CPU, memory, disk, and network interfaces.

Virtual machines are created and managed by a hypervisor (also known as a Virtual Machine
Monitor, or VMM), which runs on the host machine. The hypervisor allocates resources to
each VM and ensures that they remain isolated from one another, allowing multiple
operating systems to run concurrently without interfering with each other.

Benefits of Virtual Machines:

1. Improved Resource Utilization:

o Virtual machines enable better utilization of hardware resources by allowing

multiple VMs to share the same physical machine. This maximizes CPU,
memory, and storage utilization, making it more efficient than running a
single OS on each physical machine.

2. Isolation and Security:

o VMs provide strong isolation between different operating systems and

applications running on the same hardware. This makes them ideal for
running untrusted software or applications in a secure, sandboxed
environment. If one VM crashes or gets compromised, it does not affect other
VMs or the host system.

3. Flexibility and Portability:

o Virtual machines are highly portable, meaning they can be moved from one
physical host to another without requiring changes. This makes them ideal for
disaster recovery, testing, or deploying applications across different
environments. The VM image, along with its OS and applications, can be
easily transferred or replicated to another system.

4. Cost Efficiency:

o Virtualization allows organizations to consolidate their hardware

infrastructure by running multiple VMs on a single physical machine, leading
 to significant cost savings. This reduces the need for purchasing additional
physical servers, lowers energy consumption, and simplifies management and
maintenance.

5. Snapshot and Cloning:

o VMs can be snapshotted, which means capturing the exact state of the VM at
a particular moment in time. This feature allows users to roll back to a
previous state in case of errors or system failures. Additionally, VMs can be
cloned, which means creating identical copies of the VM for replication,
backup, or deployment purposes.

6. Simplified Management and Maintenance:

o Virtual machines can be managed, monitored, and updated centrally, making

it easier to handle system administration tasks. VMs also allow for
automation of tasks, such as software updates or resource allocation, which
simplifies ongoing system maintenance.

Assignment No. 2
1. Define a process in the context of operating systems.

A process in the context of operating systems refers to an instance of a program that is being
executed. It is not just the program itself but also a dynamic entity consisting of multiple
components such as the program code, the current state of execution, and various resources
used by the program. These resources may include CPU registers, memory space (both
physical and virtual), files, I/O devices, and other system resources.

At its core, a process is the execution of a program, and it acts as the smallest unit of work
that can be managed by the operating system. When a program is loaded into memory and
begins execution, it transitions from a static, passive program (a set of instructions) into an
active, executing process. The operating system assigns resources to the process, manages
its state, and ensures that it gets appropriate CPU time, which allows it to run concurrently
with other processes.

A process includes:

1. Program Code (Text Segment): The actual instructions of the program that will be
executed. This is typically read-only memory that ensures the code is not modified
during execution.

2. Stack: The region that holds the function calls, local variables, and returns addresses.
It is crucial for managing the flow of execution and keeping track of function calls and
their parameters.
 3. Heap: The memory area used for dynamic memory allocation. It is managed by the
process to allocate and free memory during execution.

4. Data Section: Contains global and static variables used by the program. These are
initialized values or data used throughout the execution of the program.

5. Program Counter (PC): Keeps track of the next instruction to be executed.

6. CPU Registers: Hold the current state of the process, such as general-purpose
registers, stack pointers, and other context-specific information.

7. File Descriptors: A list of files or resources opened by the process.

8. Process ID (PID): A unique identifier assigned to each process by the operating

system.

The operating system manages the lifecycle of processes, from their creation to termination.
Processes are created when a program is executed, scheduled for execution by the CPU, and
terminated once their execution completes or when the system kills them due to an error or
system request. Process isolation is key for ensuring that processes do not interfere with
each other and cause system instability. In a multi-tasking environment, the operating
system ensures that processes are given access to the CPU in a fair and efficient manner
through techniques like scheduling, priority management, and process switching.

Relationship Between Processes and Threads

Within a process, execution is typically carried out by threads, which are the smallest unit of
execution within a process. Each process can have multiple threads (known as
multithreading). These threads share the same memory space but have their own program
counter, register set, and stack. This allows for concurrent execution of multiple tasks within
the same process.

The operating system plays an essential role in managing the interaction between processes,
threads, and resources. It ensures that system resources are allocated efficiently and that
processes do not interfere with each other, leading to a stable, secure, and high-
performance system. This is achieved through mechanisms like process scheduling,
synchronization, and inter-process communication (IPC).

Example

To illustrate, consider a simple example of a text editor. The text editor application is written
as a program, but when you open it and begin typing, the operating system creates a
process for that instance of the program. As you type, the text editor process executes and
updates the content in memory, handling inputs from the keyboard and outputs to the
display. If the editor allows you to open multiple files, each file could be managed by a
separate process or thread within the main text editor application.
In summary, a process is the execution of a program that involves both the code and the
associated resources, with the operating system managing its lifecycle and ensuring safe
execution.

2. Explain the different states of a process and draw a diagram of the process state
transition.

In operating systems, a process undergoes a series of transitions between different states

during its lifecycle, from creation to termination. The process states reflect the current status
of a process and are essential for efficient resource management, scheduling, and process
coordination. The most common process states are:

1. New: The process is being created. It is in the initial phase where the operating
system allocates necessary resources for the process. This state is transitional, and
the process hasn’t started execution yet. The OS prepares the process for the ready
state by loading it into memory, assigning a unique process ID, and setting up the
process control block (PCB).

2. Ready: The process has been loaded into memory and is ready to execute, but it is
waiting for the CPU to become available. The ready state means that the process is
capable of running as soon as the CPU is assigned to it by the operating system. All
processes in the ready state are kept in the ready queue, and the operating system
uses scheduling algorithms to determine which process gets to use the CPU next.

3. Running: When the CPU is allocated to a process, it enters the Running state. In this
state, the process is executing instructions, performing calculations, accessing
memory, interacting with I/O devices, and so on. The process remains in this state as
long as it is executing. However, it may be preempted (interrupted) by the operating
system to allow another process to run or if it finishes its time slice in a time-sharing
system.

4. Waiting (Blocked): When a process needs to wait for some external event, such as
the completion of an I/O operation, data from another process, or a signal, it enters
the Waiting or Blocked state. While in this state, the process is not eligible for CPU
time until the event it’s waiting for occurs. This may involve waiting for the
completion of disk I/O, user input, or other processes to release resources.

5. Terminated (Exit): Once a process has finished executing or is forcibly terminated

due to errors or signals from other processes, it enters the Terminated state. The
operating system performs cleanup tasks, such as deallocating memory, releasing
resources, and removing the process from the system. The process is now completely
finished, and no further execution occurs.

Process State Transition Diagram:

The process state transitions depend on events like the availability of the CPU, I/O events, or
the completion of process execution. These transitions guide the process through different
states:

Explanation of Transitions:

• New → Ready: The transition from the New state to the Ready state occurs when
the process has been created, initialized, and loaded into memory but is not yet
running. The process is now ready to be scheduled by the operating system.

• Ready → Running: The transition from Ready to Running happens when the process
is chosen by the scheduler and assigned the CPU for execution. The process then
begins its execution. It could happen immediately or after some time, depending on
the scheduling algorithm being used.
 • Running → Waiting: A running process may transition to the Waiting state if it
requires resources or data that are not yet available. For example, if a process is
waiting for disk I/O, it will be put in the Waiting state, where it will remain until the
I/O operation completes or the required resource becomes available.

• Running → Ready: A process may transition back to the Ready state if it is

preempted (interrupted by the OS) or voluntarily yields the CPU, usually because it
has completed its allocated time slice or a higher-priority process needs the CPU. The
process is then added back to the ready queue to wait for its turn again.

• Waiting → Ready: When the event that the process is waiting for (e.g., I/O
completion) occurs, the process transitions back to the Ready state. The process is
now ready to execute but still needs to wait for its turn to be assigned CPU time.

• Running → Terminated: Once a process finishes executing, either because it

completes its task or because it is killed due to errors or signals, it enters the
Terminated state. In this state, the operating system cleans up the process by
deallocating resources, closing open files, and removing it from the scheduling
system.

• Blocked (Waiting) → Terminated: In rare cases, a process that is in the Blocked state
might transition directly to the Terminated state if it encounters a critical error, an
external signal to terminate, or other exceptional circumstances.

Process Management and Scheduling:

The operating system uses these states and transitions to manage process execution and
ensure efficient use of CPU and system resources. Process scheduling is an essential function
of the operating system, as it ensures that processes are executed fairly, efficiently, and
according to their priority.

• Schedulers determine when a process should transition from the ready queue to the
running state, and they use algorithms (e.g., Round Robin, First-Come-First-Served,
Priority Scheduling) to decide which process should be executed next based on
various factors such as priority, fairness, and resource availability.

• Interrupts play a key role in process state transitions. A running process may be
interrupted (preempted) by the operating system to allow another process to
execute, or it may yield the CPU voluntarily when it has no more work to do or is
waiting for an event.

Managing Multiple Processes:

The operating system’s role in managing processes extends beyond just switching between
states. Process synchronization and inter-process communication (IPC) mechanisms are
used to coordinate processes that are running concurrently, especially when they need to
share data or resources.

For example, in a multi-threaded environment, multiple threads within the same process
may share memory space but still need to communicate efficiently. The OS must ensure
proper synchronization to prevent data corruption or conflicts between threads, especially
when they access shared resources concurrently.

3. What is a Process Control Block (PCB)? List and explain three key pieces of information
stored in a PCB.

A Process Control Block (PCB) is a critical data structure in an operating system that holds
essential information about a process. It plays a crucial role in process management, as it
stores the current state, execution context, and resource details associated with a process.
When a process is created, the operating system initializes its PCB, and this data structure is
used throughout the process's lifecycle to ensure it executes smoothly and interacts properly
with the operating system.

The PCB provides a way for the operating system to track the process's state and manage its
transitions through various phases, such as running, ready, waiting, and terminated.
Whenever a context switch occurs (such as when the CPU switches from one process to
another), the operating system saves the state of the current process in its PCB and restores
the state of the new process from its PCB. This allows the system to resume execution of a
process exactly where it left off, providing multitasking and ensuring that each process gets
its fair share of CPU time.

The key purpose of the PCB is to manage all the information needed to control a process's
execution and ensure proper scheduling.

Key Information Stored in a PCB:

1. Process State:

o The Process State field in the PCB represents the current status of the process
in terms of execution. This is one of the most important pieces of
information, as it indicates whether the process is currently running, waiting,
ready, or terminated.

o Common states include:

▪ New: The process is being created.

▪ Ready: The process is ready to execute but waiting for CPU time.

▪ Running: The process is actively executing on the CPU.

▪ Waiting (Blocked): The process is waiting for some event to occur

(e.g., I/O completion).
 ▪ Terminated: The process has finished execution or has been killed.

o The state field is crucial for the operating system’s process scheduler because
it helps the OS determine the actions it needs to take regarding a process. For
example, if a process is in the Ready state, the OS will select it for execution
based on the scheduling algorithm.

2. Program Counter (PC):

o The Program Counter (PC) field stores the address of the next instruction that
is to be executed in the process. The program counter is vital because it tells
the operating system where the process was in its execution before being
interrupted or preempted.

o When a process is running, the program counter keeps track of the address of
the next instruction to be fetched and executed by the CPU. When a context
switch occurs (e.g., another process takes the CPU), the OS saves the current
value of the PC in the PCB so that when the process is scheduled again, it can
resume execution from the exact point where it left off.

o The program counter allows for accurate and efficient execution of processes,
ensuring that no instructions are skipped or repeated in the execution cycle.

3. CPU Registers:

o The CPU Registers field contains the contents of the CPU registers for the
process. CPU registers are fast, small storage areas in the CPU used to store
critical data, such as intermediate computation results, address pointers, and
control information.

o Common CPU registers stored in the PCB include:

▪ General-purpose registers: Used by the process to store variables and

temporary data.

▪ Stack pointer: Points to the top of the stack, where local variables and
return addresses are stored during function calls.

▪ Base pointer: Points to the base of the current stack frame, helping
the OS manage function calls.

▪ Status registers: Store flags and control bits that indicate specific
states of the processor, such as zero, carry, overflow, and sign flags.

o When the process is preempted or blocked, the contents of these registers

must be saved in the PCB. This ensures that when the process resumes, the
exact state of its execution is restored. Without saving these values, the
process would lose track of its execution context, leading to errors or crashes.
Other Information Stored in a PCB:

While the Process State, Program Counter, and CPU Registers are the primary components
of a PCB, there are several other fields that provide additional context and management
capabilities. These include:

4. Process ID (PID):

o The PID is a unique identifier assigned to each process by the operating

system. It is used to distinguish processes from one another and manage
them. The PID is essential for the OS to keep track of all running processes
and handle scheduling, inter-process communication, and other tasks
efficiently.

o In some systems, processes are also associated with a Parent Process ID

(PPID), which helps track the relationship between parent and child
processes, enabling process hierarchies.

5. Memory Management Information:

o This includes information about the process's memory allocation, such as

pointers to the process’s page tables, base and limit registers, or memory
segments. It helps the OS ensure that the process operates within its
allocated memory and prevents memory violations (e.g., accessing memory
outside its bounds).

o For example, in a paging or segmentation system, the PCB would contain

page table information, which helps the operating system translate logical
addresses (virtual memory) into physical memory addresses.

6. I/O Status Information:

o The I/O status information section of the PCB contains information about the
I/O operations requested by the process. This includes open files, device
status, and other I/O resources the process is using.

o The operating system uses this data to track which resources the process is
waiting for, whether it is waiting for a disk read, writing to a file, or
communicating with external devices.

7. Priority and Scheduling Information:

o This field contains information about the priority of the process, which
determines the order in which it will be scheduled for execution. In many
systems, processes with higher priority are given more CPU time, while lower-
priority processes may have to wait.
 o Scheduling information may also include the process's time quantum (in
systems with time-sharing), the priority queue it belongs to, and other
related data that helps the operating system choose which process should run
next.

8. Accounting Information:

o Accounting information includes data about the process’s CPU usage,

execution time, and other performance metrics. This information helps in
system resource management, including process billing, system monitoring,
and performance analysis.

o In some systems, this information can also include the amount of memory
used by the process, the number of I/O operations it has performed, and the
number of context switches it has undergone.

9. Inter-process Communication (IPC) Information:

o Some PCB implementations may include data related to inter-process

communication, such as the process's communication channels or shared
memory regions. This allows processes to communicate with each other and
synchronize their execution.

PCB in Action:

To better understand the role of the PCB, consider a situation in which the operating system
performs a context switch. During this process, the OS saves the state of the currently
running process (e.g., process A) in its PCB and loads the state of the next process to be run
(e.g., process B). The PCB ensures that when process A is scheduled to run again, it will
resume exactly where it left off, without losing any of its context (e.g., the current
instruction, register values, and memory contents).

When process A is preempted, the OS saves its Program Counter, CPU Registers, and
Process State in the PCB. If process A was running and is now waiting (e.g., waiting for I/O),
the PCB will reflect this change. Later, when the I/O operation completes, the process will
move back to the ready state, and its PCB will help restore the exact state of the process,
including its program counter and register values, so that it can continue execution
seamlessly.

In systems with complex multitasking, each process is continuously switching between

states, and the PCB acts as a snapshot of the process’s state at any given moment. The more
information that can be stored in the PCB, the better the operating system can manage and
control the execution of processes.

Conclusion:
The Process Control Block (PCB) is a fundamental data structure for managing processes
within the operating system. It ensures that all the necessary information about a process is
stored in one place, allowing the OS to efficiently manage the execution, scheduling, and
resources of processes. Key pieces of information stored in the PCB include the process
state, program counter, and CPU registers, but it can also include memory management
data, I/O status, priority, accounting, and inter-process communication information. By
maintaining and updating the PCB throughout the process's lifecycle, the operating system
ensures that processes are executed fairly, efficiently, and in an orderly manner.

4. What are scheduling queues in process scheduling? Name and describe the main types.

Scheduling queues are data structures that store processes waiting to be scheduled for
execution by the CPU. They help the operating system manage processes according to
scheduling algorithms. The different types of scheduling queues are:

1. Ready Queue: This queue stores processes that are ready to execute but are waiting
for the CPU. All processes in this queue have been loaded into memory and are ready
for execution as soon as the CPU is available.

2. Blocked (Waiting) Queue: This queue stores processes that are waiting for an event
to occur (such as I/O completion or a signal). These processes cannot proceed until
the event they are waiting for is triggered.

3. Suspended Queue: Some operating systems may implement additional queues like
suspended ready queue and suspended blocked queue. Processes in these queues
are suspended (i.e., swapped out of main memory) and can be resumed later when
resources become available.

5. Differentiate between shared memory systems and message-passing systems.

Shared Memory Systems:

• In shared memory systems, processes communicate by reading and writing to a

common memory region. This shared memory space allows multiple processes to
access and modify the same data.

• Advantages:

o Fast communication since no intermediate message-passing mechanism is

required.

o Direct data exchange between processes is possible.

• Disadvantages:

o Synchronization is needed to avoid conflicts when multiple processes access

shared memory at the same time.
 o Complex memory management and potential issues with access control.

Message-Passing Systems:

• In message-passing systems, processes communicate by sending messages to each

other through a communication channel. Each process has its own local memory, and
messages are explicitly sent between processes, which may be on the same machine
or across different machines.

• Advantages:

o Simplifies communication because each process has its own memory,

eliminating the need for complex synchronization.

o Easier to scale across distributed systems.

• Disadvantages:

o Slower communication due to the overhead of message passing.

o Requires efficient management of message queues and channels.