Skip to content

Latest commit

 

History

History
75 lines (54 loc) · 5.6 KB

2_Virtual Memory Memory Basics.md

File metadata and controls

75 lines (54 loc) · 5.6 KB

Virtual Memory Memory Basics

Concepts

1. Virtual Memory:

  • Definition: Virtual memory is a mechanism that provides an "idealized abstraction of the storage resources that are actually available on a given machine" which `"creates the illusion to users of a very large (main) memory."

  • Functionality: It allows a process to believe it has access to a larger amount of memory than what's physically available. It involves both hardware (physical memory + disk space) and software (OS + applications) components.

  • Size: In a 32-bit system, virtual memory is (2^{32}) bytes which is 4 GB. Every process has its own 4GB of virtual memory.

2. Physical Memory:

  • Definition: Physical memory refers to the actual RAM installed on the system.
  • Functionality: It stores program data, unlike virtual memory, which is a concept rather than a physical entity.
  • Expandability: It can be expanded by adding more RAM up to a certain limit, which is defined by the computer architecture.

3. Virtual Address Space:

  • Definition: The virtual memory assigned to a process is termed as its virtual address space.
  • Characteristic: Every byte of memory is addressable.
  • A 32-bit system has (2^{32}) virtual addresses.
  • Program Interaction: Computer programs operate using virtual memory, reading and writing data to virtual memory locations without interfacing directly with physical memory.

4. Memory Allocation in Programming:

  • Dynamic Allocation: When dynamic memory allocation is done using malloc/calloc in C programming, the memory allocated is virtual memory.
  • Program Perspective: A program doesn’t recognize the existence of physical memory; it perceives that it has \(2^{32}\) bytes of memory for data storage.

5. 32-bit and 64-bit Systems:

  • 32-bit System: Confines virtual memory to 4GB (2 to the power of 32 bytes) for each process.
  • 64-bit System: Has

Curiosity

1. How is Virtual Memory Mapped to Physical Memory?

  • Answer: Through a process called Paging,
  • the virtual memory addresses are mapped to physical memory addresses.
  • The OS, along with the Memory Management Unit (MMU), manages this mapping, ensuring isolation between the program and physical memory.

2. What Happens When Multiple Processes Claim Their Maximum Virtual Memory?

  • Answer: In modern operating systems, when multiple processes claim maximum virtual memory, the OS uses paging and swapping mechanisms to manage memory usage, ensuring that active processes have enough physical memory.
  • When physical memory is scarce, data can be moved to disk storage, which is significantly slower than RAM.

3. How is Memory Allocation Managed in a 64-bit System?

  • Answer: In 64-bit systems, the virtual address space is vastly larger (2^64 addresses). This large address space allows processes to have access to more memory, and also to manage and allocate memory more efficiently.

4. What is the Limitation of Physical Memory Extension?

  • Answer: The upper limit to which physical memory can be extended is determined by the computer architecture, specifically by the size of the address bus and data bus.

5. Explain the Concept of Paging in Detail?

  • Answer: Paging is a memory management scheme that eliminates the need for contiguous allocation of physical memory and thus nullifies the problems of fitting varying sized memory chunks onto the backing store.
  • The OS retrieves data from secondary storage in same-size blocks called pages.

6. How Does The System Handle Memory Requests Beyond the Physical Memory Available?

  • Answer: When a system tries to use more memory than the physical RAM available, it uses a portion of the hard drive, creating a swap space, to emulate physical RAM.
  • The OS will then swap data between the physical RAM and disk as needed, which can decrease performance due to the slower read/write speed of the hard disk.

# Concepts in Simple Words 🌟

  1. Virtual Memory 🧠:

    • Imagine your computer pretending it has more memory than it actually does. It promises each program a big, private space to keep their stuff (like 4GB in a 32-bit system) but secretly, it uses a mix of real (physical) memory and some space on the hard disk to fulfill this promise.

  2. Physical Memory 🛠:

    • This is the actual memory chip you plug into your computer. It can hold stuff like your programs and files, but it has a real, physical limit to how much it can hold.

  3. Virtual Address Space 🏠:

    • It’s like every program gets its own big room (like the 4GB we talked about) to keep and manage its stuff. Even though all these rooms are imaginary (virtual), each program believes its room is the only one and uses it to grab and store things.

  4. Memory Allocation 📦:

    • When your program wants to keep something (like a treasure box), it asks the system to give it some space in its room. This asking and getting space thing is done using special code words like malloc and calloc in programming.

  5. 32-bit and 64-bit Systems 🎚:

    • Think of these as different sized rulers to measure the room. A 32-bit ruler can measure a room up to 4GB big, while a 64-bit ruler can measure massively bigger rooms, allowing programs to have and use a much, much bigger space.

Remember: While all programs believe they have a big room (virtual memory) all to themselves, the computer cleverly manages the real space (physical memory) and imaginary space (swap space on disk) so that all programs can run smoothly together. 🚀🧙‍♂️