Demand paging

Short description: Method of virtual memory management

In computer operating systems, demand paging (as opposed to anticipatory paging) is a method of virtual memory management. In a system that uses demand paging, the operating system copies a disk page into physical memory only if an attempt is made to access it and that page is not already in memory (i.e., if a page fault occurs). It follows that a process begins execution with none of its pages in physical memory, and many page faults will occur until most of a process's working set of pages are located in physical memory. This is an example of a lazy loading technique.

## Contents

* 1 Basic concept
* 2 Advantages
* 3 Disadvantages
* 4 See also
* 5 References

## Basic concept

Demand paging follows that pages should only be brought into memory if the executing process demands them. This is often referred to as lazy loading as only those pages demanded by the process are swapped from secondary storage to main memory. Contrast this to pure swapping, where all memory for a process is swapped from secondary storage to main memory during the process startup.

Commonly, to achieve this process a memory management unit is used. The memory management unit maps logical memory to physical memory. Entries in the memory management unit include a bit that indicates whether a page is valid or invalid. A valid page is one that currently resides in main memory. An invalid page is one that currently resides in secondary memory. When a process tries to access a page, the following steps are generally followed:

* Attempt to access page.
* If page is valid (in memory) then continue processing instruction as normal.
* If page is invalid then a page-fault trap occurs.
* Check if the memory reference is a valid reference to a location on secondary memory. If not, the process is terminated (illegal memory access). Otherwise, we have to page in the required page.
* Schedule disk operation to read the desired page into main memory.
* Restart the instruction that was interrupted by the operating system trap.

## Advantages

Demand paging, as opposed to loading all pages immediately:

* Only loads pages that are demanded by the executing process.
* As there is more space in main memory, more processes can be loaded, reducing the context switching time, which utilizes large amounts of resources.
* Less loading latency occurs at program startup, as less information is accessed from secondary storage and less information is brought into main memory.
* As main memory is expensive compared to secondary memory, this technique helps significantly reduce the bill of material (BOM) cost in smart phones for example. Symbian OS had this feature.

## Disadvantages

* Individual programs face extra latency when they access a page for the first time.
* Low-cost, low-power embedded systems may not have a memory management unit that supports page replacement.
* Memory management with page replacement algorithms becomes slightly more complex.
* Possible security risks, including vulnerability to timing attacks; see Percival, Colin (2005-05-13). "Cache missing for fun and profit". BSDCan 2005. http://css.csail.mit.edu/6.858/2014/readings/ht-cache.pdf. (specifically the virtual memory attack in section 2).
* Thrashing which may occur due to repeated page faults.

## See also

* Page cache
* Memory management
* Virtual memory
* Lazy evaluation

## References

* Tanenbaum, Andrew S. Operating Systems: Design and Implementation (Second Edition). New Jersey: Prentice-Hall 1997.

* v
* t
* e

Memory management

* Memory management as a function of an operating system

Manual memory management|

* Static memory allocation
* C dynamic memory allocation
* new and delete (C++)

Virtual memory|

* Demand paging
* Page table
* Paging
* Virtual memory compression

Hardware|

* Memory management unit
* Translation lookaside buffer

Garbage collection|

* Boehm garbage collector
* Concurrent mark sweep collector
* Finalizer
* Garbage
* Garbage-first collector
* Mark-compact algorithm
* Reference counting
* Tracing garbage collection
* Strong reference
* Weak reference

Memory segmentation|

* Protected mode
* Real mode
* Virtual 8086 mode
* x86 memory segmentation

Memory safety|

* Buffer overflow
* Buffer over-read
* Dangling pointer
* Stack overflow

Issues|

* Fragmentation
* Memory leak
* Unreachable memory

Other|

* Automatic variable
* International Symposium on Memory Management
* Region-based memory management

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Demand paging. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Demand_paging&oldid=246614"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template