Centre for Distance & Online Education

INTERNAL ASSIGNMENT ANSWERS

SESSION SEPTEMBER 2024
PROGRAM BACHELOR OF COMPUTER APPLICATIONS (BCA)
SEMESTER II
COURSE CODE & NAME DCA1201 – OPERATING SYSTEM
CREDITS 4
NUMBER OF ASSIGNMENTS & 02
MARKS 30

SET – I
1. Discuss the types of operating systems. Write a brief note on operating system
structures?
Ans. Types of Operating Systems:
Operating systems (OS) are software systems that manage hardware
resources and provide services to application software. The different types of operating systems
include:
1. Batch Operating System: In this type, tasks are collected in a batch and processed
together without user interaction. These systems were common in early computing,
where tasks like calculations and data processing were performed in a batch queue.
2. Time-Sharing Operating System: A time-sharing OS allows multiple users to access
the system simultaneously. It divides CPU time into small slices and allocates each slice
to different users, enabling effective multitasking.
3. Real-Time Operating System (RTOS): An RTOS is designed to serve real-time
applications, where timely and deterministic responses are critical. These systems
prioritize tasks based on urgency and ensure that certain tasks meet deadlines, like in
embedded systems.
4. Distributed Operating System: This OS manages a group of independent computers,
making them appear as a single system to the user. It facilitates resource sharing across
multiple systems and provides a seamless computing environment.
5. Network Operating System (NOS): NOS allows computers to connect and share
resources over a network. It facilitates file sharing, printer sharing, and communication
between computers within a network.
6. Multiprocessing Operating System: This system uses more than one processor to
execute tasks simultaneously, improving performance. It is typically used in
environments where large tasks are split across multiple processors for faster execution.

Page 1
 Centre for Distance & Online Education
7. Mobile Operating System: Designed for mobile devices, this type of OS is optimized
for energy efficiency and touch-based interactions. Popular mobile operating systems
include Android, iOS, and HarmonyOS.
Operating System Structures
Operating system structures refer to how an operating system is organized and how its
components interact. These structures determine how the OS handles processes, memory, file
management, and device management. Some common operating system structures include:
1. Monolithic Structure: In a monolithic OS, all components (such as process
management, memory management, and file systems) run in a single address space.
This provides high performance but can make the system less modular and harder to
maintain. Examples include early UNIX versions.
2. Layered Structure: In this approach, the operating system is divided into layers, each
with specific functions. The bottom layer interacts directly with the hardware, and
higher layers provide more abstract services. This structure offers better modularity and
maintainability.
3. Microkernel Structure: A microkernel OS minimizes the core system to include only
essential services like memory management and basic process scheduling. Other
services (like device drivers and file systems) run as separate modules, allowing for
greater flexibility and security. Examples include the Minix OS.
4. Client-Server Structure: In this structure, the OS operates in a client-server model,
where the client requests services, and the server provides them. This can be found in
distributed systems, where clients may interact with different servers over a network.
5. Hybrid Structure: A hybrid OS combines elements from both monolithic and
microkernel structures. The kernel may contain a minimal set of services, with other
parts of the OS running as separate modules. Modern operating systems like Windows
and macOS use hybrid structures to balance performance and modularity.
Each of these structures influences how an OS handles resources, processes, and tasks,
contributing to its overall performance, stability, and user experience.

2. Discuss the CPU scheduling algorithms. Why is scheduling important?

Ans. CPU scheduling is the process by which the operating system decides which
process or task gets to use the CPU at any given time. The goal is to ensure efficient CPU
utilization, fair resource distribution, and system responsiveness. Several CPU scheduling
algorithms are designed to handle different system workloads and achieve these goals. Here
are some of the key scheduling algorithms:

Page 2
 Centre for Distance & Online Education
1. First-Come, First-Served (FCFS):
o Description: FCFS is the simplest scheduling algorithm, where processes are
executed in the order they arrive in the ready queue.
o Advantages: It is easy to implement and understand.
o Disadvantages: It can lead to long wait times, especially if a long process
arrives before a shorter one (known as the "convoy effect").
o Use Case: Useful in systems where predictability and simplicity are priorities,
though it is less efficient in times of high system load.
2. Shortest Job First (SJF):
o Description: In this non-pre-emptive algorithm, the process with the shortest
burst time (i.e., the shortest CPU time needed) is selected for execution first.
o Advantages: It minimizes average waiting time and is considered optimal in
terms of minimizing average completion time.
o Disadvantages: It requires knowledge of the future burst times, which is not
always feasible. It can also lead to starvation for longer processes.
o Use Case: Best suited for environments where burst times are predictable.
3. Round Robin (RR):
o Description: In this pre-emptive algorithm, each process is assigned a fixed
time slice (or quantum) to execute. If the process does not complete within that
time, it is moved to the back of the ready queue, and the CPU is allocated to the
next process.
o Advantages: Fairly distributes CPU time among all processes and provides
reasonable response times.
o Disadvantages: If the time slice is too large, it can resemble FCFS, and if it's
too small, the overhead of context switching becomes significant.
o Use Case: Commonly used in time-sharing systems and environments where
fairness and quick response times are essential.
4. Priority Scheduling:
o Description: Each process is assigned a priority. The process with the highest
priority is executed first. If two processes have the same priority, other
algorithms like FCFS or SJF are used to determine the order.
o Advantages: It allows more important tasks to complete first.

Page 3
 Centre for Distance & Online Education
o Disadvantages: Low-priority processes can starve if high-priority tasks
continuously enter the system. This can be mitigated with techniques like aging,
where the priority of waiting processes is gradually increased over time.
o Use Case: Suitable for systems that need to prioritize specific tasks, like real-
time systems.
5. Multilevel Queue Scheduling:
o Description: In this algorithm, processes are divided into different priority
queues based on their characteristics (e.g., interactive vs. batch processes). Each
queue has its own scheduling algorithm, and processes are assigned to a queue
based on their priority.
o Advantages: It allows efficient management of different types of processes by
using different algorithms for each queue.
o Disadvantages: It can be complex to implement, and processes may get stuck
in low-priority queues.
o Use Case: Used in systems with a mix of interactive and batch processing tasks.
6. Multilevel Feedback Queue Scheduling:
o Description: This is a refinement of multilevel queue scheduling. It allows
processes to move between queues based on their behavior, with the goal of
balancing CPU time for both short and long processes.
o Advantages: It dynamically adjusts to the characteristics of processes, offering
better responsiveness and fairness.
o Disadvantages: It is more complex to implement and may require significant
tuning to ensure optimal performance.
o Use Case: Often used in general-purpose operating systems to handle diverse
types of workloads.
Importance of Scheduling
Scheduling is a critical component of operating systems because it directly impacts the overall
system performance and user experience. Here are some key reasons why scheduling is
important:
1. Efficient CPU Utilization: The CPU is one of the most valuable resources in a
computer system. Efficient scheduling ensures that the CPU is used as much as
possible, minimizing idle time and improving overall system throughput.
2. Fairness: Scheduling algorithms help ensure that all processes are given a fair share of
CPU time, preventing situations where some processes monopolize the system while
others starve.

Page 4
 Centre for Distance & Online Education
3. System Responsiveness: In interactive systems, such as desktop environments,
scheduling is crucial to provide a fast response to user inputs. Scheduling ensures that
short tasks or interactive processes get prioritized to avoid sluggishness.
4. Meeting Deadlines: In real-time systems, scheduling is essential for ensuring that time-
sensitive tasks meet their deadlines. This is especially critical in applications such as
embedded systems, medical devices, and automotive control systems.
5. Optimizing Throughput and Latency: Proper scheduling improves the throughput
(the number of processes completed in a given time) and reduces latency (the delay
before a process starts executing). This results in better system performance and a more
efficient workflow.
6. Avoiding Resource Contention: Scheduling helps manage resources efficiently by
allocating them in such a way that processes do not excessively compete for the CPU
or other resources, leading to better overall system performance.
In summary, CPU scheduling is essential for balancing system loads, providing timely
execution of tasks, and ensuring that system resources are used effectively and fairly. The
choice of scheduling algorithm depends on the specific needs of the system, whether it's
optimizing for fairness, minimizing response time, or meeting strict deadlines.

3. Discuss Interprocess Communication and critical-section problem along with use

of semaphores.
Ans. Interprocess Communication (IPC):
Interprocess Communication (IPC) refers to the mechanisms that allow processes to
communicate with each other and synchronize their actions in a multi-process environment.
Since processes typically run independently and have their own memory space, IPC provides
a way for them to exchange data and coordinate their operations. IPC is essential for systems
with multiple concurrently running processes, as it enables cooperation and prevents conflicts
or resource contention.
There are several IPC methods, including:
1. Message Passing: This involves processes sending and receiving messages to
communicate with one another. It can be done either directly (between two processes)
or indirectly (through a message queue). Message passing is commonly used in
distributed systems.
2. Shared Memory: In this method, processes communicate by accessing a common
region of memory. One process writes to the shared memory, while others read from it.
This is a faster method of IPC compared to message passing, but it requires
synchronization to avoid conflicts.

Page 5
 Centre for Distance & Online Education
3. Pipes: A pipe is a communication channel that allows one process to send data to
another. There are two types: anonymous pipes (used for communication between
related processes) and named pipes (used for communication between unrelated
processes).
4. Sockets: Sockets provide a way for processes to communicate over a network. This
method is often used in client-server applications, allowing processes on different
machines to communicate.
5. Signals: Signals are a form of IPC that allows a process to send notifications to another
process. For example, a process may send a signal to notify another process of an event,
like the need for it to terminate.
The Critical-Section Problem
The critical-section problem arises in concurrent programming when multiple processes
attempt to access and modify shared resources simultaneously, leading to potential conflicts,
inconsistencies, or data corruption. The "critical section" refers to a part of the program where
shared resources are accessed or modified.
To solve this problem, the following conditions must be met:
1. Mutual Exclusion: Only one process can be in its critical section at a time. This
prevents race conditions, where the outcome depends on the order of process execution.
2. Progress: If no process is in its critical section and some processes are waiting to enter,
then one of the waiting processes must be allowed to enter the critical section. This
prevents indefinite blocking (or starvation).
3. Bounded Waiting: Each process must have a limit on how long it must wait before
entering its critical section. This ensures fairness and prevents starvation for any
process.
Several approaches are used to address the critical-section problem, with synchronization
techniques such as semaphores, mutexes, and locks being some of the most common.
Use of Semaphores in Synchronization
Semaphores are synchronization primitives used to control access to shared resources and
prevent conflicts in concurrent programming. They provide a way to manage critical sections
and solve problems like deadlock and race conditions. A semaphore consists of a variable and
two atomic operations: wait (also called P or down) and signal (also called V or up).
1. Binary Semaphore (Mutex): A binary semaphore is a semaphore with only two
possible values: 0 and 1. It is often used as a mutual exclusion lock (mutex) to ensure
that only one process at a time can enter a critical section.

Page 6
 Centre for Distance & Online Education
o Wait operation: If the value of the binary semaphore is 1, the process can enter
the critical section, and the semaphore is set to 0. If the value is 0, the process
must wait until the semaphore is set back to 1.
o Signal operation: When a process exits the critical section, it performs the
signal operation, setting the semaphore back to 1, allowing other processes to
enter.
2. Counting Semaphore: A counting semaphore can have any integer value, and it is used
to control access to a pool of resources, such as a fixed number of identical printers or
database connections. When a process wants to use a resource, it performs the wait
operation. When it is done, it performs the signal operation.
o Wait operation: The process checks the semaphore value. If it is greater than
0, the process proceeds, and the value is decremented. If the value is 0, the
process is blocked until the semaphore is incremented.
o Signal operation: When a process releases a resource, it performs the signal
operation, increasing the semaphore value, allowing other processes to acquire
the resource.
Example of Semaphores in Solving the Critical-Section Problem
Consider two processes (P1 and P2) that need to access a shared resource. Using semaphores,
we can control their access to avoid conflicts.
1. Initialization:
o Initialize a binary semaphore mutex to 1.
2. Process 1 (P1) and Process 2 (P2):
o P1:
1. Wait on the semaphore: wait(mutex) → If the value is 1, P1 enters the
critical section.
2. Access the shared resource.
3. Signal the semaphore: signal(mutex) → Releases the critical section.
o P2:
1. Wait on the semaphore: wait(mutex) → If the value is 1, P2 enters the
critical section.
2. Access the shared resource.
3. Signal the semaphore: signal(mutex) → Releases the critical section.

Page 7
 Centre for Distance & Online Education
By using semaphores to enforce mutual exclusion, only one process can access the shared
resource at a time, preventing conflicts and ensuring consistent results.
Conclusion
Interprocess communication (IPC) and synchronization mechanisms like semaphores are
crucial in ensuring that multiple processes can cooperate efficiently in a multi-process
environment. IPC enables processes to exchange information and coordinate their actions,
while semaphores provide a mechanism to handle critical sections and avoid race conditions.
Proper synchronization prevents data inconsistencies, resource contention, and deadlocks,
which are common challenges in concurrent programming.

SET – II
1. What is a Process Control Block? What information does it hold and why? What
are monitors? What is it role?
Ans. Process Control Block (PCB):
A Process Control Block (PCB) is a data structure used by the operating system to store
information about a process. Each process running in a system is represented by a PCB, and
the operating system uses this information to manage and track the process throughout its
lifecycle, from creation to termination.
Information Stored in a PCB:
1. Process ID (PID): A unique identifier assigned to each process by the operating system,
used to differentiate between processes.
2. Process State: The current state of the process, such as:
o New: The process is being created.
o Ready: The process is waiting for CPU time.
o Running: The process is currently being executed.
o Waiting: The process is waiting for some event or resource (e.g., I/O).
o Terminated: The process has finished execution.
3. Program Counter (PC): A pointer to the address of the next instruction to be executed
in the process. It helps the OS know where to resume execution when the process is
scheduled again.
4. CPU Registers: A set of registers that store the process's current working values, such
as general-purpose registers, stack pointers, and other CPU-specific registers. These are
saved and restored when the process is context-switched.

Page 8
 Centre for Distance & Online Education
5. Memory Management Information: Information related to memory allocation for the
process, such as base and limit registers, page tables, or segment tables. This helps the
operating system manage the process's memory and ensures it accesses valid memory
locations.
6. I/O Status Information: This includes information about the resources allocated to the
process, such as open files, devices in use, and other I/O resources.
7. Process Priority: The priority of the process, which helps the operating system decide
the order in which processes are scheduled to use the CPU.
8. Accounting Information: Information about the process’s resource usage, such as
CPU time consumed, memory usage, and number of I/O operations. This data can be
useful for process scheduling and performance analysis.
9. Parent and Child Process Information: For managing relationships between
processes, such as the parent-child hierarchy. It includes information about the process's
parent process and its children.
Why Does the PCB Hold This Information:
The PCB holds this information to enable the operating system to effectively manage and
control processes. When a process is suspended or blocked (such as waiting for I/O), the
operating system can save the state of the process in its PCB. Later, when the process is
resumed, the OS can retrieve this information and continue the process from where it left off.
The PCB also allows the OS to:
 Context-switch between processes, storing and restoring necessary data to ensure
smooth transitions.
 Track and manage resources assigned to each process.
 Maintain process state and ensure correct execution behavior.
Monitors in Operating Systems
A monitor is a high-level synchronization construct used in concurrent programming to control
access to shared resources by multiple processes or threads. It is an abstraction that simplifies
synchronization and helps manage concurrent access to shared data structures or devices.
Key Characteristics of Monitors:
1. Encapsulation: A monitor encapsulates both data and the operations (procedures or
methods) that operate on that data. The monitor ensures that only one process or thread
can execute any of its procedures at a time, preventing race conditions.
2. Condition Variables: A monitor typically includes condition variables, which are used
for process synchronization. Condition variables allow processes to wait until a certain
condition holds true (e.g., when a resource becomes available).

Page 9
 Centre for Distance & Online Education
3. Mutex (Mutual Exclusion): Inside a monitor, the procedures that access shared data
are automatically mutually exclusive. This means that only one thread or process can
execute any of the monitor’s procedures at a time, avoiding conflicts over shared
resources.
Role of Monitors:
Monitors serve as a higher-level abstraction compared to semaphores and other
synchronization mechanisms. Their primary role is to manage synchronization and ensure that
only one process or thread can access shared resources at a time while simplifying the process
of coding synchronization logic. Here are the main roles of monitors:
1. Simplifying Synchronization: Monitors abstract away much of the complexity of
managing synchronization, making it easier to write correct, concurrent programs. By
encapsulating both data and operations, monitors eliminate the need for manual locking
and unlocking of resources, reducing the risk of errors like deadlocks or race conditions.
2. Providing Mutual Exclusion: A monitor guarantees that only one process or thread
can be executing inside it at any given time. This ensures safe access to shared resources
or data structures and prevents concurrency issues like race conditions.
3. Providing Condition Synchronization: Monitors provide condition variables, which
enable processes to wait for specific conditions to be met (e.g., waiting for a resource
to become available). Processes can wait within the monitor until a particular condition
is satisfied, at which point they can continue execution.
4. Coordination of Concurrent Processes: Monitors allow processes to cooperate with
each other by sharing and modifying data in a controlled and synchronized manner.
This is especially important in multi-threaded or multi-process applications where
multiple entities need to work with shared data.
Example of Monitor Use:
Consider a situation where multiple processes need to access a shared buffer. Using a monitor,
you can define operations such as "produce" and "consume" that interact with the buffer. If the
buffer is full, the "produce" operation will cause the process to wait until space is available.
Similarly, if the buffer is empty, the "consume" operation will cause the process to wait until
there is something to consume.
In summary, monitors simplify the process of synchronizing concurrent processes by providing
a structured way to handle mutual exclusion and condition synchronization. They are essential
in managing shared resources in a safe and efficient manner in modern operating systems.

Page 10
 Centre for Distance & Online Education
2. Discuss the different File Access Methods. What are I/O Control Strategies?
Ans. File Access Methods:
File access methods define how data is read from or written to a file. There are several types
of file access methods, each suited for different needs and applications:
1. Sequential Access:
o This is the simplest and most common access method. In sequential access, data
is read or written in a linear sequence, from the beginning of the file to the end.
o It is used when data needs to be processed in order, such as in text files, logs, or
record-based files.
o Example: Reading or writing to a text file one line at a time.
2. Direct Access (Random Access):
o In direct access, data can be read or written at any point in the file without the
need to read through previous data.
o This method allows for faster retrieval, especially for large files where only
specific data is required.
o Example: Database systems use direct access to retrieve a specific record using
an index.
3. Indexed Access:
o Indexed access uses an index to keep track of where data is located in the file,
improving retrieval efficiency.
o The index stores pointers to the data, enabling fast access without scanning the
entire file.
o Example: A file of records with an index on a particular field, such as a
customer ID.

4. Hashed Access:
o In hashed access, a hash function is used to determine the location of data in the
file. This method maps data directly to a location using a hashing algorithm.
o It is highly efficient for operations like searching or updating a specific entry.
o Example: Storing customer data with unique IDs using a hash table.

Page 11
 Centre for Distance & Online Education
I/O Control Strategies
I/O control strategies manage how the operating system interacts with hardware devices and
files to improve efficiency, minimize latency, and optimize system performance. These
strategies include:
1. Buffering:
o Buffering involves temporarily storing data in memory (a buffer) before it is
transferred to the final destination, reducing the number of I/O operations.
o It helps avoid frequent disk access by grouping multiple operations into a single
one.
o Example: A file is read into a buffer in chunks rather than reading byte-by-byte,
which improves performance.
2. Spooling:
o Spooling refers to the process of placing data into a queue for later processing,
typically used in printing or batch processing.
o It allows the system to continue processing other tasks while waiting for I/O
operations to be completed.
o Example: When multiple print jobs are sent to a printer, they are spooled and
printed one after the other.
3. Caching:
o Caching involves storing frequently accessed data in faster memory (such as
RAM) to reduce the need to repeatedly read from slower storage devices like
hard drives.
o It minimizes the delay for subsequent accesses to the same data.
o Example: Web browsers cache images, scripts, and other assets for faster page
load times.

4. I/O Scheduling:
o I/O scheduling determines the order in which I/O operations are executed. The
goal is to optimize the system's response time, throughput, and fairness among
tasks.
o Example: Disk scheduling algorithms like FCFS (First-Come-First-Serve) or
SSTF (Shortest Seek Time First) control the order in which disk operations are
performed.

Page 12
 Centre for Distance & Online Education
5. Disk Access Optimization:
o This strategy focuses on reducing the time spent on accessing files stored on
physical disks.
o Techniques include using algorithms to minimize seek time (e.g., SCAN or C-
SCAN algorithms), reducing rotational latency, and utilizing parallel I/O
operations.
o Example: A disk scheduling algorithm that minimizes the movement of the disk
arm, reducing the seek time for file accesses.
6. Asynchronous I/O:
o Asynchronous I/O allows I/O operations to occur in the background while the
CPU continues executing other tasks. This prevents the system from being
blocked by I/O operations and improves efficiency.
o Example: When saving a file, the operating system may continue other
processes while the file is being written to disk in the background.
These strategies help to optimize data handling, minimize processing time, and ensure smooth
interaction between hardware and software components in computing systems.

3. Explain Paging and Segmentation along with page map table and internal external
fragmentation details.
Ans. Paging and Segmentation:
Both paging and segmentation are memory management techniques that allow the operating
system to manage and allocate memory efficiently. However, they work in different ways, and
each has its strengths and weaknesses.
Paging:
Paging is a memory management scheme that eliminates the need for contiguous allocation of
physical memory. It divides physical memory into fixed-size blocks called pages, and logical
memory (process address space) is divided into blocks of the same size, called page frames.
 How it works:
o When a program is loaded into memory, it is divided into pages, and each page
is stored in available memory frames. The pages do not have to be stored
contiguously in physical memory, which allows for efficient use of space.
o A Page Table is maintained to map virtual addresses (the program's logical
address space) to physical addresses in memory.

Page 13
 Centre for Distance & Online Education
o This mapping enables the operating system to use any available free memory
block, making paging a highly flexible and efficient method of memory
allocation.
 Page Table:
o The Page Table stores the mapping between the logical page number and the
corresponding physical frame number in memory.
o Each entry in the page table holds the address of the physical page in memory.
o The size of the page table depends on the size of the memory and the size of
each page.
 Advantages:
o Eliminates the problem of external fragmentation because pages can be placed
anywhere in physical memory.
o Provides efficient memory use, especially when there are processes that need
non-contiguous allocation.
 Disadvantages:
o Internal Fragmentation: This can occur when a process does not completely
fill the allocated page, leaving small unused portions within the page.
o Overhead: Managing page tables requires additional memory and can increase
overhead, particularly for large address spaces.
Segmentation:
Segmentation is another memory management scheme that divides memory into variable-
sized segments based on the logical divisions in a program, such as functions, arrays, and data
structures. Each segment is treated as a separate entity, with its own base and limit.

 How it works:
o Unlike paging, which divides the program into equal-sized blocks,
segmentation divides a program into variable-sized segments based on logical
grouping.
o A Segment Table maps each segment to a corresponding physical location in
memory. Each entry in the segment table contains the base address of the
segment and its length.
o The program's logical address consists of a segment number and an offset
within the segment. The segment number is used to access the segment table,
and the offset determines the position within that segment.

Page 14
 Centre for Distance & Online Education
 Advantages:
o Offers a more natural and intuitive view of memory, as it divides memory into
meaningful segments like code, data, and stack.
o Allows for better protection and sharing of memory between different
processes.
 Disadvantages:
o External Fragmentation: Since segments are of varying sizes, they may not fit
into available free space, leading to fragmentation outside the allocated
segments.
o Overhead due to managing different segments and ensuring their correct
placement.
Page Map Table:
The Page Map Table is used in systems that implement paging. It maps virtual pages to
physical frames. This table is essential for converting a virtual address to a physical address
during memory access.
 Structure: The page map typically consists of an array of entries where each entry
corresponds to a virtual page. Each entry in the page table holds the frame number
where the page is stored in physical memory.
 Types of Page Tables:
o Single-Level Page Table: A straightforward table mapping each virtual page to
a physical frame.
o Multi-Level Page Table: Used for large address spaces, this method breaks
down the page table into several levels to reduce memory overhead for
managing the table.
Internal and External Fragmentation
Fragmentation refers to the inefficiency in memory utilization, and it can be categorized into
two types: internal fragmentation and external fragmentation.
Internal Fragmentation:
 Definition: Internal fragmentation occurs when memory is allocated in fixed-size
blocks (such as pages in paging or fixed-sized blocks in some allocation schemes), but
the process does not use the entire block.
 This leftover unused space within a block is wasted.

Page 15
 Centre for Distance & Online Education
 Example: In a system using paging, if each page is 4 KB, and a process only needs 5
KB, it will require two pages. The second page will have 3 KB of unused space, leading
to internal fragmentation.
 Mitigation: Internal fragmentation can be reduced by using smaller allocation units or
more flexible memory management techniques.
External Fragmentation:
 Definition: External fragmentation happens when free memory is split into small
blocks scattered across the memory, leaving no single contiguous block large enough
to satisfy a process's memory request.
 Unlike internal fragmentation, external fragmentation involves the wasted space
between allocated memory blocks.
 Example: In a system using segmentation, if a process needs 10 KB of memory but
only 2 separate blocks of 5 KB each are free, the system cannot allocate the memory,
even though there is enough total free space.
 Mitigation: External fragmentation can be reduced using techniques like compaction
(rearranging memory to create larger contiguous free blocks) or using paging, which
eliminates the need for contiguous allocation.
Summary:
 Paging divides memory into fixed-sized blocks (pages) and uses a page table to map
virtual addresses to physical addresses.
 Segmentation divides memory into variable-sized logical segments and uses a segment
table to manage them.
 Page Map Table manages the mapping between virtual pages and physical frames in
memory.
 Internal Fragmentation refers to wasted space within an allocated block (page), and
External Fragmentation refers to unused gaps between allocated memory blocks.

Page 16