NAPACHIHI

Memory Management.
Memory management is a fundamental aspect of operating systems that involves controlling and
coordinating computer memory, including assigning portions of memory to various programs to
optimize overall system performance. This includes the management of both physical memory (RAM)
and virtual memory.
VIRTUAL MEMORY.
Virtual memory is a technique that gives the illusion of a large, contiguous block of memory, even if the
actual physical memory (RAM) is smaller. It allows programs to use more memory than what is
physically available by using disk space to simulate additional RAM.
Advantages:
Larger Address Space: Programs can use more memory than physically available.
Memory Isolation: Each process has its own virtual address space, improving security and stability.
Efficient Memory Use: Only necessary data is loaded into physical memory, saving space.
Disadvantages:
Performance Overhead: Accessing data on disk is slower than accessing RAM, which can slow down
programs.
Complexity: Managing virtual memory adds complexity to the operating system.
Demand Paging
Demand paging is a technique where only the necessary parts of a program are loaded into memory as
needed, rather than loading the entire program at once. This conserves memory and improves
efficiency.
Advantages:
 Memory Efficiency: Reduces the amount of physical memory required.
 Faster Startup: Programs start faster since not all data is loaded at once.
 Better Utilization: More programs can run simultaneously due to efficient memory use.
Disadvantages:
 Page Faults: Frequent page faults (when required data is not in memory) can slow down
performance.
 Overhead: Managing which pages to load and when adds overhead to the system.
 Complexity: Increases the complexity of both hardware and software to handle paging.
Page Replacement:
When a computer needs to access data not currently in physical memory, it causes a "page fault." To
handle this, the operating system must decide which existing page in memory to remove to make room
for the new one. Algorithms used for this decision include:
 Least Recently Used (LRU): Removes the page that hasn't been used for the longest time.
 First-In-First-Out (FIFO): Removes the oldest page in memory.
 Clock: A more efficient version of LRU, using a circular list and a "use" bit to keep track of pages.
Allocation of Frames.
In virtual memory systems, physical memory is divided into fixed-size blocks called frames, while virtual
memory is divided into similar-sized blocks called pages. Allocating frames involves mapping these
virtual pages to physical frames in RAM. This helps in using the physical memory efficiently.
Memory-Mapped Files.
Memory-mapped files allow programs to access files by mapping them directly into their virtual
memory. This method makes file I/O operations faster and simpler, as the file is treated as part of the
program's memory.
Advantages:
 Faster access to file data.
 Simplified coding for file access and manipulation.
 Efficient memory usage for large files.
Disadvantages:
 Can consume a lot of virtual address space.
 Increased complexity in handling file synchronization.
 Potential issues with data consistency if multiple processes modify the file simultaneously.
Allocating Kernel Memory.
Kernel memory allocation refers to the process by which the operating system's kernel manages and
allocates memory for its own use. Unlike user-level memory allocation, which is often managed through
libraries like malloc in C, kernel memory allocation must be highly efficient and reliable due to the
critical nature of kernel operations.
How It Works.
a) Fixed-size Allocation (Slab Allocator):
 The kernel often uses a slab allocator for allocating memory. This allocator manages memory in
slabs, which are collections of small, fixed-size blocks of memory.
 When the kernel needs memory, it requests a block from the appropriate slab. If no suitable slab
is available, a new one is created from larger contiguous chunks of physical memory.
b) Variable-size Allocation (Buddy System):
 For larger, variable-sized memory requests, the kernel may
 use a buddy system allocator. This system divides memory into power-of-two sized blocks.
 When memory is allocated, the system finds the smallest available block that fits the request.
If the block is too large, it is split into two "buddies" of equal size until a suitable block size is
obtained.
Advantages:
1. Efficiency:
 Slab allocation is efficient for frequent small memory requests, as it reduces fragmentation and
speeds up allocation and deallocation.
 The buddy system efficiently handles larger memory allocations by minimizing wasted space
through splitting and coalescing blocks.
2. Performance:
 Both systems reduce fragmentation, leading to better performance. Slab allocation, in
particular, allows for quick access to frequently requested sizes.
3. Predictability:
 Fixed-size allocations ensure predictable performance, which is crucial for real-time systems
where timing is critical.
Disadvantages:
1. Complexity:
 Implementing these allocation strategies adds complexity to the kernel's memory management
code.
2. Memory Overhead:
 Slab allocation can lead to memory overhead due to pre-allocation of memory blocks that
might not be fully utilized.
 The buddy system can suffer from internal fragmentation when the allocated block size is
larger than the requested memory.
3. Scalability Issues:
- As the number of memory requests increases, maintaining efficient allocation and deallocation can
become challenging, potentially leading to performance bottlenecks.

NAPACHIHI

Uploaded by

Copyright:

Available Formats

NAPACHIHI

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

NAPACHIHI

Uploaded by

Copyright:

Available Formats

Memory Management.

Complexity: Managing virtual memory adds complexity to the operating system.

 Memory Efficiency: Reduces the amount of physical memory required.

 First-In-First-Out (FIFO): Removes the oldest page in memory.

 Faster access to file data.

 Simplified coding for file access and manipulation.

 Efficient memory usage for large files.

 Can consume a lot of virtual address space.

 Increased complexity in handling file synchronization.

a) Fixed-size Allocation (Slab Allocator):

b) Variable-size Allocation (Buddy System):

 For larger, variable-sized memory requests, the kernel may

You might also like

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.