Your memory must support both the operating system’s (kernel) processes and user (private) processes. These steps happen when a you start a program.
- The operating system creates an address space for the program to run in, which involves setting up appropriate page tables.
- The program’s text and data segments are mapped from the executable file on disk to the virtual address space; the text being mapped as read only, the data being mapped as read-write.
- The stack and heap are initialized. (Whatever it means..forget it for this moment)
- Control is transferred to the program.
- The processor tries to access the first instruction. Since it is not in memory, a page fault is generated.
This causes the operating system to intervene and allocate one or more pages of physical memory and to copy the code from the file. There you get the name: “Demand Paged Virtual Memory.”
- The processor then returns control to the program, which continues executing until it encounters another page fault. At this point, step 5 is repeated.
- If there is no free physical memory, the operating system will have to
- either discard (if read only) or
- swap out (write data to swap file if read write) pages before they can be reused.
- Typically a least recently used (LRU) algorithm is used for deciding which pages get tossed.
- This pattern continues for the life of the program.
When you executes a program, the operating system creates an address space for it to run in. This address space will include the instructions for the program itself, as well as any data it requires.
In a system with memory protection, each process is restricted by the operating system to access only the memory in its own address space. However, the combined program memory requirements often exceed the system’s amount of physical memory installed on a computer. Therefore your operating system uses a portion of the hard disk called a swap file to extend the amount of available memory. This technique, called virtual memory, treats physical memory as a cache of the most recently used data.
In a virtual memory system, memory is divided into units called pages. A page is typically 4-8 KB in size. The set of addresses that identify locations in virtual memory is called the virtual address space (VAS). Each process is allocated a virtual address space. The virtual address space can range from zero to 4 GB on a 32-bit architecture.
A process’s address space contains the set of instructions and data that is mapped into virtual memory when a program is executed. Virtual memory addresses are translated into physical memory addresses through the use of a look-up table, called a page table. In addition to mapping the entire process into virtual memory, a subset of pages is also mapped into physical memory. As each instruction in the process executes, it is either found in physical memory or is not found (called a page fault).
When a page fault occurs, the page that is needed must be moved from the hard disk into physical memory before the instruction can be executed. To make room for the new page, the operating system may need to decide which page to move out of physical memory. This is called swapping. A page fault is time consuming because retrieving data from the hard disk is much slower than obtaining it directly from the physical memory. Operating systems attempt to minimize the number of page faults by swapping multiple pages at once. This becomes a trade-off between operating system overhead and the time saved by minimizing page faults, which is affected by the size of each process’s working set.
The operating system takes care of swapping and translating from virtual address space to physical address space. With a virtual memory scheme, the amount of memory available is seemingly limited only by the amount of hard drive space. Virtual memory has more memory available than physical memory because it removes the restriction that an entire process must be loaded into memory at one time.
Now read (if you did not already) the post about OOM Errors