Virtual memory

Virtual memory

Virtual memory is a memory management technique that allows a computer to use more memory than what is physically available in RAM. It creates an illusion for the user that there's more RAM than there actually is by using a combination of the computer's RAM and a portion of the hard drive. 

Imagine you have a computer with 4 GB of RAM, but you're running several programs that together require 6 GB of memory. The operating system will use 4 GB from the physical RAM and then take 2 GB from the hard drive, which acts as an extension of the RAM. This portion of the hard drive is called the swap space or page file. Here's how it works:

  • Running Programs: Suppose you're using a browser, a word processor, and a game simultaneously.
  • Memory Requirement: These applications together need more memory than your 4 GB of RAM can provide.
  • Swapping: The OS decides which parts of the data or applications are not actively in use and temporarily moves them from RAM to the swap space on the hard drive.
  • Accessing Data: When the data in the swap space is needed again, the OS will swap it back into RAM, possibly swapping out some other data to the hard drive. 
Advantages of Virtual Memory:
  • Efficient Use of Memory: Virtual memory allows the operating system to use disk space as an extension of RAM, enabling more processes to run simultaneously, even if they collectively require more memory than is physically available.
  • Larger Address Space: It provides processes with a larger address space than the physical memory, enabling the execution of large applications that wouldn’t fit entirely in RAM.
Disadvantages of Virtual Memory:
  • Slower Performance: Accessing data from the hard drive (which is used in virtual memory) is much slower than accessing data from RAM, which can lead to significant performance drops, especially if the system heavily relies on swapping.
  • Increased Complexity: Managing virtual memory adds complexity to the operating system, including the need for sophisticated algorithms for page replacement and memory allocation.
  • Potential for Thrashing:  If the system relies too heavily on swapping, it can lead to thrashing, where the OS spends more time swapping pages in and out of memory than executing processes, resulting in severe performance degradation.
Demand paging 
It is a technique in virtual memory management where pages of data (sections of a program) are loaded into RAM only when they are needed (or "demanded") by a process. Instead of loading the entire program into memory at once, the operating system loads only the pages that are currently required.
How Demand Paging Works:
  • Process Starts: When you start a program, instead of loading the entire program into RAM, the OS only loads the essential parts needed to begin execution.
  • Page Fault: If the program needs to access a page that isn't currently in RAM (because it hasn't been loaded yet), a "page fault" occurs. This is an event that tells the OS to fetch the needed page from the hard drive (or swap space) and load it into RAM.
  • Loading the Page: The OS then retrieves the required page from the disk and loads it into RAM. The program can then continue running as if the page had been there all along.
  • The valid-invalid scheme in demand paging is a method used by the operating system to manage and track which pages of a process's memory are currently in RAM and which are not. 
  • Valid Bit: The page table entry has a valid bit that indicates whether the page is currently in RAM.  
  • Valid (1): The page is in RAM, so the CPU can directly access it. 
  • Invalid (0): The page is not in RAM; it might be on the disk (e.g., in a swap file) or not allocated yet.

What is a Page fault?

A page fault happens when a program tries to access a part of its memory (a page) that is not currently in the computer's RAM. This usually occurs because the needed page is stored on the hard drive or hasn't been loaded into RAM yet.

How is a Page Fault Generated:
  • Program Execution: A program (process) runs and tries to access some data.
  • This data is in a specific page of the program's memory.
  • Memory Access: The CPU checks if the page is in RAM by looking at the page table, which keeps track of where each page is stored.
  • Page Table Check: If the page is not in RAM (the valid bit in the page table is set to 0), a page fault occurs because the CPU can't find the page in the memory.
How is a Page Fault Handled:
  • Pause the Program: When a page fault occurs, the operating system pauses the program because it needs to bring the missing page into RAM.
  • Locate the Page: The operating system finds where the needed page is stored on the hard drive.
  • Load the Page into RAM: The OS loads the page from the hard drive into an available space in RAM.
  • Update the Page Table: The page table is updated to reflect that the page is now in RAM (the valid bit is set to 1).
  • Resume the Program: The program is resumed from where it left off, and it can now access the data it needs from 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