Unit IV Memory Management

Memory management in operating systems involves fulfilling various requirements to

ensure efficient use of memory resources. Here are the fundamental memory
management requirements:

1. Relocation: Programs should be able to execute in any available part of the physical
memory. Relocation is essential to support multiprogramming where multiple
processes are loaded into memory simultaneously. It allows flexibility in memory
allocation, enabling the efficient use of available memory space.

2. Protection: Processes must be isolated and protected from each other to prevent
unauthorized access to memory locations. Memory protection mechanisms ensure that
a process cannot access memory that has not been allocated to it. This prevents
interference between processes and enhances system stability and security.

3. Sharing: In some cases, it's beneficial for multiple processes to share a portion of
memory. Memory management should support mechanisms for shared memory to
enable efficient communication and collaboration between processes, improving
overall system performance.

4. Logical Organization: Memory should be organized logically to allow for efficient

and easy access to data and instructions. Logical organization might involve dividing
memory into segments or pages, enabling better management and retrieval of
information.

5. Physical Organization: Efficient use of memory space and access speed is crucial.
Physical organization techniques aim to minimize access times by arranging memory
in a way that reduces bottlenecks and maximizes data retrieval speed.

6. Optimization: Memory management should strive to optimize overall system

performance by minimizing fragmentation, reducing overheads, and effectively
utilizing available memory resources.
Meeting these requirements ensures that the operating system can efficiently manage
memory, allowing multiple processes to run concurrently while maintaining system
stability, security, and performance. Various memory management techniques and
algorithms are employed to fulfill these requirements based on the specific
characteristics and needs of the system.

Memory partitioning is a memory management technique used by operating systems

to allocate available memory space to multiple processes. It involves dividing the
physical memory into separate partitions or sections, which can be allocated to
different programs or processes. Two primary types of memory partitioning
techniques are fixed partitioning and dynamic partitioning.

Fixed Partitioning:

In fixed partitioning, the memory is divided into fixed-sized partitions at system

startup or configuration time. Each partition remains the same size throughout the
execution of the system. These fixed-sized partitions are then allocated to processes as
needed.

Characteristics:
- Static Allocation: The partitions are allocated to processes when they start, and the
size remains fixed.
- No Fragmentation: Since partitions are fixed, there's no external fragmentation
within each partition.
- Limited Flexibility: Processes are restricted to a specific partition size, which might
lead to inefficient use of memory for smaller processes.

Advantages:
- Simple implementation.
- No dynamic memory allocation overhead.

Disadvantages:
- Inefficient use of memory for processes smaller than the partition size.
- Wastage of memory space due to fixed sizes.
- Limited flexibility in accommodating varying-sized processes.

Dynamic Partitioning:

Dynamic partitioning, also known as variable partitioning, addresses the inflexibility

of fixed partitioning by allowing partitions to vary in size based on the size of the
processes requesting memory. When a process arrives, the operating system allocates
memory according to the process's size, creating a partition of a suitable size.

Characteristics:
- Variable Partition Sizes: Partitions are created dynamically based on process size,
reducing internal fragmentation.
- More Efficient Utilization: Better accommodation of varying process sizes leads to
improved memory utilization.
- Potential Fragmentation: Dynamic allocation and deallocation of memory can cause
fragmentation, leading to inefficient use of memory space.

Advantages:
- Better accommodation of processes with varying memory requirements.
- Reduced internal fragmentation compared to fixed partitioning.

Disadvantages:
- Increased complexity in memory management due to dynamic resizing of partitions.
- Possibility of fragmentation issues, especially if memory isn't managed effectively.

Both fixed partitioning and dynamic partitioning have their pros and cons. Fixed
partitioning is simpler but might lead to inefficient memory usage, especially for
varying process sizes. Dynamic partitioning offers better memory utilization but
requires more complex management to handle varying process sizes and potential
fragmentation issues. Operating systems typically select one of these techniques based
on the system's requirements and the nature of processes it needs to handle.

The Buddy System is a memory allocation technique that falls under dynamic
partitioning methods. It is used to assign memory to processes by dividing the
available memory into fixed-size blocks that are powers of 2 (e.g., 1KB, 2KB, 4KB,
etc.). Each block is referred to as a 'buddy' and has a specific size that is a power of 2.

When a process requests a certain amount of memory, the system allocates a block
that is equal to or slightly larger than the requested size. If a suitable block is not
available, the system splits a larger block into two equal-sized buddies until a block of
adequate size is obtained.

How the Buddy System Works:

1. Initialization: The entire memory space is considered as a single block, typically

the largest power-of-2 size.
2. Allocation: When a process requests memory, the system searches for the smallest
available block that can accommodate the requested size. If the block is larger, it is
split into two equal-sized buddies.
3. Deallocation: When a process releases memory, the system checks if its buddy (if
available) is also free. If both buddies are free, they are merged back into a larger
block.

Advantages of the Buddy System:

1. Reduced Fragmentation: It minimizes external fragmentation by dividing memory

into fixed-sized blocks, which reduces the waste of memory due to fragmentation.
2. Simple Implementation: The algorithm for splitting and merging blocks is
straightforward compared to other dynamic allocation methods.
3. Efficient Searching: It can efficiently find suitable memory blocks of the required
size by using powers-of-2 block sizes.

Disadvantages of the Buddy System:

1. Internal Fragmentation: It can suffer from internal fragmentation as the allocated

memory might be slightly larger than requested due to block sizes being powers of 2.
2. Limited Block Sizes: The rigid nature of block sizes being powers of 2 might lead
to inefficient memory allocation for processes that don’t fit perfectly into these sizes.
Despite its advantages, the Buddy System is more suitable for scenarios where power-
of-2 block sizes align well with the memory requirements of processes. It’s efficient
in reducing external fragmentation but may cause some internal fragmentation due to
block size constraints. Operating systems often use this technique in specific contexts
where it aligns with the memory allocation needs of the system's processes.

Relocation in computer science and operating systems refers to the process of

adjusting the references within a program or a process from one memory location to
another. It's a fundamental aspect of memory management, allowing programs to
execute in any available part of the physical memory.

Key Points about Relocation:

1. Program Execution: When a program is loaded into memory for execution, it might
not always occupy the same memory location. Different instances of the same
program or different programs might be loaded into different memory locations.

2. Memory Addressing: Programs use memory addresses to reference data and

instructions. However, these addresses are typically relative to the program's starting
location in memory.

3. Need for Relocation: For various reasons, such as memory constraints or the
presence of multiple processes in memory simultaneously, programs need to be
loaded into available memory locations. Relocation facilitates this flexibility.

4. Relocation Register/Program Counter: The operating system uses a relocation

register or a program counter to track and adjust memory addresses dynamically
during the program's execution. This register holds the base address of the currently
allocated memory block for the process.

5. Address Translation: Whenever the program references a memory location, the

hardware (often assisted by the operating system) translates the virtual address (used
by the program) into a physical address (actual memory location) by adding the base
address from the relocation register.

6. Dynamic Loading and Relocation: Some operating systems support dynamic

loading, where parts of a program are loaded into memory only when they are needed.
This requires relocation to place these segments in available memory areas.

Importance of Relocation:

- Multiprogramming: In systems that support multiple processes simultaneously,

relocation allows efficient utilization of memory space by loading programs and data
into available memory locations dynamically.

- Security: Relocation can be used as a security measure to prevent malicious

programs from predicting or accessing specific memory locations by constantly
changing the memory address space.

Challenges with Relocation:

- Fragmentation: Frequent relocation of processes can lead to fragmentation of

memory, both internal (within allocated blocks) and external (unused gaps between
allocated blocks).

- Overhead: The process of relocating programs incurs some overhead due to the need
for address translation and management of relocation registers.

Relocation is a critical component of memory management, enabling efficient use of

memory and supporting the dynamic execution of multiple programs concurrently in
modern operating systems.

Paging is a memory management scheme used by operating systems to manage

memory allocation for processes. It's a technique that breaks the physical memory into
fixed-size blocks called "pages" and manages the processes' memory in these fixed-
size units. Simultaneously, the logical memory or address space of a process is
divided into equal-sized blocks called "frames."

Key Components and Features of Paging:

1. Page and Frame Size: Pages in memory and frames in the process's logical address
space are of the same fixed size. Common sizes include 4KB or 8KB.

2. Address Translation: To translate a logical address generated by the CPU into a

physical address, the operating system maintains a page table. This table maps the
pages of the process to the corresponding frames in physical memory.

3. Page Table: The page table stores the mapping information for each page of a
process, indicating where each page resides in physical memory. It typically includes
a page number and a frame number.

4. Page Faults: When a process references a page that is not currently in physical
memory (a page fault), the operating system triggers a page replacement mechanism
to bring the required page into memory from secondary storage (like a hard drive).

5. Page Replacement Algorithms: Various algorithms (e.g., Least Recently Used -

LRU, First-In-First-Out - FIFO) are used by the operating system to select which page
to remove from memory when space is needed for a new page. This involves
swapping pages in and out of the memory.

6. Fragmentation: Paging reduces external fragmentation since memory allocation is

done in fixed-size blocks (pages). However, it can lead to internal fragmentation if the
last page of a process is not completely filled.

Advantages of Paging:

- Simplifies Memory Management: It simplifies memory allocation by breaking

memory into fixed-size pages, allowing more efficient utilization of memory space.
- Reduces Fragmentation: Paging reduces external fragmentation compared to other
memory allocation techniques like variable partitioning.

Challenges and Considerations:

- Overhead: Paging introduces overhead due to the maintenance of page tables and the
need for frequent address translations.
- Page Table Size: Large address spaces may require extensive page tables, which can
consume significant memory space.
- Page Replacement Overhead: Selecting pages for replacement involves algorithmic
overhead, especially in scenarios of high memory pressure.

Paging is widely used in modern operating systems due to its ability to efficiently
manage memory allocation, reduce fragmentation, and provide a flexible memory
management scheme for handling multiple processes concurrently.

Segmentation is another memory management technique used in operating systems.

Unlike paging, which divides memory into fixed-size blocks (pages), segmentation
divides a program's logical address space into variable-sized segments. Each segment
represents a logical unit such as a function, procedure, or data structure within a
program.

Key Concepts of Segmentation:

1. Variable-Sized Segments: Segments are not of uniform size. Instead, they

correspond to different parts of a program, such as code, data, stack, heap, etc. Each
segment has its own size, defined by the programmer.

2. Segment Table: Similar to a page table in paging, segmentation uses a segment

table to map each segment of a program to its corresponding physical memory
location. The segment table stores the base address and the length of each segment.
3. Address Translation: When the CPU generates a logical address, the operating
system uses the segment table to translate this address into a physical address by
adding the base address of the corresponding segment.

4. Protection and Sharing: Segmentation provides a means of protection and sharing

by assigning permissions (read, write, execute) to different segments. It also allows
sharing of segments between different processes or users.

5. Fragmentation: Segmentation can suffer from fragmentation issues, such as

external fragmentation, where free memory becomes fragmented into small unusable
blocks between segments.

6. Segmentation Faults: When a process tries to access a segment that is not part of its
address space or exceeds its allocated boundaries, a segmentation fault occurs,
resulting in termination or interruption of the process.

Advantages of Segmentation:

- Logical Organization: Segmentation reflects the natural structure of programs,

making it more intuitive for programmers.
- Protection and Sharing: Segments can be protected and shared independently,
enhancing security and facilitating interprocess communication.

Challenges and Limitations:

- Fragmentation: Segmentation can lead to external fragmentation due to varying

segment sizes, causing inefficient memory utilization.
- Complexity: Managing variable-sized segments and their table entries can be
complex, especially when dealing with a large number of segments or processes.

Combined Approach: Paging and Segmentation:

In many modern systems, a combination of paging and segmentation, known as

"paged segmentation" or "segmented paging," is used to leverage the advantages of
both techniques while mitigating their individual limitations. This hybrid approach
combines the logical structure of segmentation with the memory management
efficiency of paging.

Segments are divided into fixed-size pages, offering the flexibility of segmentation
while reducing external fragmentation through the use of fixed-size page frames. This
combination provides better memory management and address space representation
for complex programs and diverse memory allocation needs.

Virtual memory is a memory management technique that uses both hardware and
software to provide the illusion of a larger address space than the physical memory
available in a computer system. It allows processes to execute as if they have access
to a larger contiguous address space than what is physically present.

Hardware Components:

1. Memory Management Unit (MMU):

- The MMU is a hardware component that handles the translation of virtual
addresses to physical addresses.
- It works in conjunction with the operating system and translates the virtual
addresses generated by the CPU into corresponding physical addresses.
- It performs address translation using page tables or other mapping structures.

2. Translation Lookaside Buffer (TLB):

- The TLB is a high-speed cache within the MMU that stores recently accessed
mappings of virtual addresses to physical addresses.
- It speeds up the address translation process by holding frequently used address
mappings, reducing the need to access the main memory or page tables for every
translation.

Control Structures:

1. Page Tables:
 - Page tables are a crucial control structure used by the operating system and the
MMU to map virtual addresses to physical addresses.
- Each process has its own page table that stores the mapping information for its
virtual memory pages.
- The page table contains entries that specify the mapping between the virtual pages
and their corresponding physical page frames in the main memory.

2. Page Fault Handling Mechanism:

- When a process tries to access a virtual page that is not currently present in
physical memory, a page fault occurs.
- The operating system handles page faults by bringing the required page from
secondary storage (like a hard disk) into the physical memory.
- It updates the page table to reflect the new mapping and allows the process to
continue execution.

3. Memory Protection Bits:

- These bits within the page table entries define the access permissions for each
page (e.g., read-only, read-write, execute permissions).
- They ensure that processes cannot access memory locations they are not
authorized to, enhancing system security and stability.

4. Segmentation Mechanisms (Optional):

- Some systems use segmentation alongside paging. In such cases, control structures
for segmentation, like segment tables, work in tandem with page tables to manage the
address space effectively.

Benefits of Virtual Memory:

- Maximizes Memory Utilization: It allows efficient utilization of available physical

memory by swapping data between RAM and secondary storage.
- Supports Multitasking: Multiple processes can run concurrently without requiring
each to fit entirely in physical memory.
- Simplifies Programming: It simplifies programming by providing a large,
contiguous address space to processes, making memory management transparent to
programmers.

Virtual memory is a fundamental concept in modern operating systems, enabling

efficient and flexible memory management, improved system performance, and
support for multitasking environments. Its hardware components and control
structures work in tandem to provide a seamless and expanded memory space for
executing processes.

Operating system (OS) software serves as the core software that manages computer
hardware resources and provides various services to applications and users. It acts as
an intermediary between the hardware and user-level software, ensuring efficient
utilization of system resources while providing an interface for users to interact with
the computer.

Key Components of Operating System Software:

1. Kernel:
- The kernel is the heart of the operating system, responsible for managing resources
like CPU, memory, I/O devices, and handling essential functions such as process
scheduling, memory management, and device management.
- It operates in privileged mode, having direct access to the hardware, and manages
system calls made by user-level processes.

2. Device Drivers:
- Device drivers are software components that facilitate communication between the
operating system and hardware devices such as printers, disks, graphics cards, and
network interfaces.
- They enable the operating system to control and utilize different hardware devices
by providing a standardized interface.

3. File System Management:

 - The file system manages the organization and storage of files on storage devices
such as hard drives, SSDs, and external storage.
- It provides functions for file creation, deletion, reading, and writing, and maintains
a hierarchical structure of directories and files.

4. Memory Management:
- Memory management involves allocating and deallocating memory resources to
processes efficiently.
- It handles tasks such as virtual memory management, address translation, and
allocation of physical memory.

5. Process and Task Management:

- Process management involves creating, scheduling, and terminating processes, as
well as managing inter-process communication and synchronization.
- Task management oversees various tasks within the system, assigning priorities
and resources to ensure smooth operation.

6. Security and Access Control:

- Operating systems implement security measures to protect system resources, such
as user authentication, access control lists, and permissions.
- They manage user accounts, ensuring that users have appropriate access to
resources and preventing unauthorized access.

7. System Calls and APIs:

- System calls provide a way for user-level programs to request services from the
operating system, such as opening files, creating processes, and managing memory.
- Application Programming Interfaces (APIs) offer a higher-level interface for
developers to access OS functionalities in a standardized way.

8. User Interface:
- The user interface allows users to interact with the operating system. It can be a
command-line interface (CLI) or a graphical user interface (GUI), providing ways to
run applications, manage files, and configure system settings.
Operating system software is critical for managing resources, providing a stable
environment for software execution, and facilitating user interaction with the
computer system. It forms the backbone of modern computing by enabling efficient
utilization of hardware resources and providing a platform for running applications.