Memory Management Techniques

Without virtual memory 

  • In a multiprogramming environment, multiple processes are loaded into RAM to maximize CPU utilization and overall system efficiency. Let's consider an example where three processes, P1, P2, and P3, are allocated specific memory spaces in RAM. The operating system occupies the initial portion of RAM, followed by P1 in the memory range 50-60, P2 in the range 60-70, and P3 in the range 90-100.
  • Now, suppose P1 contains a line of code that attempts to access a memory location by adding 10 to the current address. If the current address is 55, this calculation would result in an address of 65, which falls within the memory space allocated to P2. This situation would violate memory protection and process isolation principles, as P1 should not be aware of or able to access the memory allocated to P2.
  • To prevent such violations, there must be mechanisms in place to ensure that each process operates within its allocated memory space without interfering with others.
With virtual memory

  • In a multiprogramming environment, the OS doesn't directly allocate processes to specific physical locations in RAM. Instead, it introduces a layer of abstraction between processes and physical memory to ensure memory protection and isolation.
  • For instance, suppose we have two processes, P1 and P2, each requiring 16KB of memory. In virtual memory, both P1 and P2 start their address space at 0, making them independent from each other. The OS then maps these virtual addresses to physical addresses in RAM. For example, P1's virtual address space from 0 to 16KB might be mapped to physical addresses 128 to 144, and P2's space might be mapped to addresses 64 to 80.
  • This abstraction allows each process to operate as if it has its own dedicated memory starting from address 0. However, behind the scenes, the OS manages the actual physical addresses. If, for example, a programmer in P2 tries to access an address that, when translated, falls outside its allocated range (e.g., 125, which is within P1's range), the OS detects this using the base (here 64) and offset values (here 16) for P2. The OS then throws an exception, indicating an illegal memory access attempt, thereby preventing any violation of process isolation.

The memory Management Unit (MMU) is a crucial component of the computer's hardware responsible for handling memory access and virtual memory management. The MMU translates virtual addresses used by programs into physical addresses used by the hardware. Components of the MMU:
  • Relocation Register (Base Register):  Holds the base address of the process’s allocated memory in physical memory.
  • Limit Register (Bounds Register): Specifies the size (offset) of the process’s allocated memory space.
1. Process Information:
  • Virtual Address Space: The process P1 has a virtual memory range from 0 to 10.
  • Base Value: The base address in physical memory is 50.
  • Limit Register: The limit register value is 10, indicating the maximum offset allowed in the process's address space.
2. CPU Generates Logical Address:
  • Logical Address: The CPU generates a logical address of 5.
3. Limit Register Check: 
  • The limit register is used to ensure that the logical address does not exceed the bounds of the process's allocated virtual memory, if the value exceeds the bound then the addressing error will be thrown.
  • In this case, the limit register value is 10, and the logical address 5 is less than 10. Therefore, the address is within the allowed range.
4. Address Translation: 
  • Base Value Addition: To convert the logical address to a physical address, the base value (50) is added to the logical address (5).
  • Physical Address Calculation:
  • Physical Address=Base Value+Logical Address
  • Physical Address=50+5=55
  • Accessing Physical Memory: The calculated physical address is 55. The CPU will access this address in RAM.




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