Skip to content

Latest commit

 

History

History
99 lines (72 loc) · 8.66 KB

10_1:1 Mapping between Physical and Virtual Page.md

File metadata and controls

99 lines (72 loc) · 8.66 KB
Raw

1:1 Mapping between Physical and Virtual Page

🔍 1:1 Mapping in Memory Management:

  • Virtual Page: Essentially a set of virtual addresses.
    • One virtual page has (2^{12}) or 4096 virtual addresses, each providing access to one byte of data in physical memory.
  • Physical Page: Can be either on disk or in memory and
    • is the actual storage entity that holds the data corresponding to a virtual address.
  • Mapping: Every virtual page is mapped to a corresponding physical page, creating a 1:1 relationship between them.
  • Data Storage: While virtual pages do not store actual data but reference it, physical pages do store the actual byte data.
  • Virtual Address Space: Is segmented and may contain various sections like the code segment and data segments, which are stored in physical pages upon process execution.
  • Dynamic Memory Allocation: Using functionalities like malloc, new virtual and physical pages might be created to satisfy a program's demand for memory.

🔍 Process Execution and Memory:

  • Execution: When a process is executed, physical pages (P0, P1, P2, etc.) are created by the OS to store machine code instructions and data segments.
  • Data Segments: The physical pages will hold the actual initialized and uninitialized data segments upon process execution.
  • Dynamic Allocation: Additional physical and virtual pages can be created upon request (e.g., when a program uses dynamic memory allocation functions like malloc).

🔍 Memory Allocation Granularity:

  • Page Size: A fixed size, e.g., 4096 bytes, which is the unit in which OS allocates or releases memory.
  • Malloc Requests: A malloc request may not result in new pages if existing pages have enough memory space to satisfy the request.

Curiosity 🤔

  1. Question: How does the OS manage the 1:1 mapping between virtual and physical pages effectively? Answer: Through the use of Page Tables and/or TLBs (Translation Lookaside Buffers), the OS manages mappings efficiently. The virtual page number is used as an index into the page table, providing the corresponding physical page number, ensuring a quick translation and maintaining the 1:1 mapping.

  2. Question: In what scenario might there not be a direct 1:1 mapping between virtual and physical pages? Answer: In an Overcommitted Virtual Memory system, the OS may assign more virtual memory to processes than the available physical memory, breaking the 1:1 mapping. This is often managed through swapping pages in and out of physical memory and using techniques like Demand Paging.

  3. Question: How does the operating system handle page requests when physical memory is full? Answer: The OS utilizes a Page Replacement Algorithm (such as LRU - Least Recently Used, FIFO - First In First Out, etc.) to decide which page to swap out from physical memory to the disk (swap space) to make room for the new page.

  4. Question: What is the significance of having a 1:1 mapping in memory management, and are there alternative mapping approaches? Answer: 1:1 mapping ensures a straightforward translation between virtual and physical addresses, aiding in simple and efficient memory management. Alternative approaches might involve multi-level page tables, inverted page tables, or hashed page tables, which handle mappings differently, catering to various needs and scenarios in memory management.

  5. Question: How does the operating system differentiate between different types of data segments during a process’s execution? Answer: The OS differentiates by recognizing predefined sections within the virtual address space of a process, such as code segment, data segment, heap, and stack. Each type of segment has a particular purpose and characteristics, and memory is allocated accordingly during execution.

  6. Question: What are the implications of not having a physical page for every virtual page in real-time applications? Answer: Lack of 1:1 mapping in real-time systems could lead to issues like page faults, which can incur a significant time penalty, thus potentially violating real-time constraints and affecting the timeliness and predictability of the system.

Concepts in Simple Words 📘

In computer memory management, we often use a concept called Virtual Memory to help manage and use our computer's physical memory (or RAM) more effectively. Here, we have something called Virtual Pages and Physical Pages.

  • Virtual Pages: Imagine you have a big book 📖 and each page of the book is a "virtual page". However, this book doesn't actually have any real content; it’s like a catalogue, telling you where to find the actual content.

  • Physical Pages: Now, think of a physical page like a small box 📦. These boxes actually hold the true content (data or instructions) that you’re looking for.

When you look at a page in your virtual book, it tells you which box (physical page) to go to find the actual information. This is the 1:1 mapping 🗺️: for every page in your book, there is a box that holds the actual goodies. So, when a computer program needs some data, it looks at its virtual page, finds out which physical page (box) it needs, and goes and gets the data from there!

In practical scenarios, when a software is running, it might need more pages (or boxes) to store extra stuff. This can be like when a game loads a new level or when your browser opens a new tab 🎮🌐. The Operating System helps manage all of this, ensuring each virtual page points to the right physical page, and that every bit of data is stored securely and can be accessed when needed!

Diagram illustrating the concept of virtual pages within a process's virtual address space and their corresponding physical pages within physical memory. The arrows symbolize the 1:1 mapping between them.

Virtual Address Space of a Process     Mapping     Physical Memory of a Process
---------------------------------     --------     ----------------------------
+------------------------+             |              +------------------------+
|                        |             |              |                        |
|     Virtual Page 0     |-------------|------------->|     Physical Page 2     |
|                        |             |              |                        |
+------------------------+             |              +------------------------+
|                        |             |              |                        |
|     Virtual Page 1     |-------------|------------->|     Physical Page 5     |
|                        |             |              |                        |
+------------------------+             |              +------------------------+
|                        |             |              |                        |
|     Virtual Page 2     |-------------|------------->|     Physical Page 1     |
|                        |             |              |                        |
+------------------------+             |              +------------------------+
|                        |             |              |                        |
|     Virtual Page 3     |-------------|------------->|     Physical Page 3     |
|                        |             |              |                        |
+------------------------+             |              +------------------------+

Explanation:

  • Virtual Address Space of a Process:

    • Virtual Page 0, Virtual Page 1, etc., represent different portions of the virtual memory allocated to a process. These virtual pages provide a way for the process to address memory locations.

  • Mapping:

    • The arrows symbolize the mapping or the relation between virtual pages and physical pages. This mapping ensures that whenever the process tries to access a memory location via virtual memory, it gets directed to the right place in physical memory.

  • Physical Memory of a Process:

    • Physical Page 1, Physical Page 2, etc., represent actual data storage spots in RAM. Note that these physical pages are not necessarily in a contiguous block or in order, so a page in the physical memory may be stored in a non-contiguous manner.

In this example:

  • Virtual Page 0 maps to Physical Page 2.
  • Virtual Page 1 maps to Physical Page 5.
  • Virtual Page 2 maps to Physical Page 1.
  • Virtual Page 3 maps to Physical Page 3.

This illustrates that virtual pages and physical pages are mapped 1:1, but not in contiguous or ordered fashion, helping to efficiently utilize physical memory and manage process memory in a manner that is both secure and isolated from other processes. This abstraction also simplifies memory management from a programming and OS perspective.