Drawback of paging and how to solve it

Drawbacks of paging

When pages are scattered far apart in physical memory, it can lead to additional drawbacks:

1. Reduced Cache Efficiency:

  • Explanation: If the pages of a process are spread out across distant locations in RAM, it can reduce the efficiency of the CPU cache, which relies on the locality of reference. The CPU cache works best when data is close together, as it can quickly load and reuse it. When data is scattered, it increases the chances of cache misses, slowing down memory access.
  • Example: Imagine a book is split into sections and stored on shelves all over a large library (representing RAM). If you have to walk across the library to read each section, it takes much longer than if the sections were on the same or nearby shelves. Similarly, if pages of a process are spread far apart in memory, the CPU might need to fetch data from multiple distant locations, reducing performance

2. Increased Page Table Lookup Time:

  • Explanation: If the pages of a process are not stored contiguously in RAM, the Memory Management Unit (MMU) might have to work harder to translate logical addresses to physical addresses. Each lookup involves accessing different parts of the RAM, which can take more time, especially if those parts are far apart.
3. Internal Fragmentation:
  • Explanation: Pages are of fixed size, but the data within them might not fill the entire page. This unused space within a page leads to wasted memory, known as internal fragmentation.
  • Example: If each page is 4KB, but a process only needs 2KB of space, the remaining 2KB is wasted. Even if there are multiple such processes, all the extra unused space adds up, leading to inefficient memory use.
What is segmentation?

Segmentation is a memory management technique where a process's memory is divided into different segments based on its logical structure, like code, data, and stack. Each segment is independent and has its own base and limit values. Segmentation allows each segment to grow independently, unlike paging where the memory is divided into fixed-size pages.

Example:
Imagine a simple program with three parts:
  • Code segment: Where the instructions of the program are stored.
  • Data segment: Where the program's variables and data are stored.
  • Stack segment: Where function calls and local variables are handled.
Let's say:
  • The Code segment is 10 KB.
  • The Data segment is 5 KB.
  • The Stack segment is 3 KB.

Disadvantages of Segmentation: 
  • External Fragmentation: Since segments are of variable sizes, as processes are loaded and unloaded from memory, free memory can become fragmented into small, non-contiguous blocks. Over time, this can make it difficult to allocate large segments, even if enough total free memory is available. 
  • Example: Imagine you have 100 KB of free memory, divided into blocks of 30 KB, 40 KB, and 30 KB. Now, suppose a process requires a segment of 50 KB. Even though you have 100 KB total free memory, you can't allocate the 50 KB segment because there's no single contiguous block of 50 KB available. The small free blocks scattered around the memory are not useful for this large segment.

Comments

Post a Comment

Popular posts from this blog

Indexed allocation

Image
  Indexed allocation is a file allocation method used by operating systems to manage how files are stored on disk. The core idea is simple but powerful: instead of storing a file in contiguous blocks or linking blocks one-by-one, the system uses a special index block that contains a list of all the disk block addresses where the file’s data is stored. This removes many limitations of earlier methods like contiguous and linked allocation. In indexed allocation, each file has its own index block . This index block acts like a table of contents. Every entry inside it points to a data block that belongs to that file. When a file is created, the OS allocates an index block and then fills it with pointers to the actual data blocks as the file grows. These data blocks can be located anywhere on the disk , so the file does not need contiguous space. This makes storage much more flexible and avoids external fragmentation. When the system needs to access a particular part of a file, it fir...
Read more

Thrashing

Image
Thrashing occurs in a computer system when the operating system spends a significant amount of time swapping pages in and out of memory, rather than executing actual processes. This typically happens when the system's memory is overcommitted, meaning there are too many processes competing for too little physical memory, leading to frequent page faults. How Memory is Used 1. Initial State: App1 is running, and its two pages are loaded into memory: Frame 1: App1, Page 1 Frame 2: App1, Page 2 Frame 3 and 4 are free. App3's pages are present in swap memory. 2. Switch to App2: Now, you switch to App2, which also requires 2 pages: Frame 3: App2, Page 1 Frame 4: App2, Page 2 Memory is now full with both App1 and App2’s pages. App3's pages are present in swap memory. 3. Switch to App3: You decide to switch to App3, which needs 2 pages as well. Since the memory is full, the system needs to make room: App1’s pages are moved to swap memory: Swap Memory: [App1, Page 1] [App1, Page 2] F...
Read more

Basics of paging

Image
Paging is a memory management scheme that eliminates the need for contiguous allocation of physical memory and thus helps in handling fragmentation. It involves breaking down memory into fixed-size blocks called pages and frames. The OS typically decides the page size when the system is configured or during the OS design phase. This page size is constant for the entire system and is determined based on considerations such as hardware architecture, efficiency, and the type of applications running. Common page sizes are 4 KB, 8 KB, or 16 KB. Here's a simple explanation with an example: Basic Concepts Page: A fixed-size block of logical memory (virtual memory) used by a process. Frame: A fixed-size block of physical memory (RAM) where a page is mapped. Page Table: A data structure used by the operating system to keep track of the mapping between pages and frames. The Page Table Base Register (PTBR) is a special register in the CPU that holds the starting address of the page table for ...
Read more