Virtual address space

From Wikipedia, the free encyclopedia

Virtual address space (abbreviated VAS) is a memory mapping mechanism available in modern operating systems such as OpenVMS, Unix, Linux, and Windows NT.

[edit] Overview

When you run an application on a 32-bit operating system (OS), the OS creates a new process for it. This process has a 4GB VAS: each one of the memory addresses (from 0 to 232-1) in that space can have a single byte as value. Initially, none of them have values.

Virtual memory is easiest to comprehend if one thinks in terms of the VAS, and not the physical memory of the machine nor the size of its page file. Byte values in the VAS come only from byte values in a file. The OS manages the mapping between the VAS and the files that hold its values.

Physical memory comes in various flavors: on-chip cache, off-chip cache, and system memory. As far as the process is concerned, system memory is just another level of cache used by the OS. System memory has a lot to do with performance, but nothing to do with the architecture of a process. The process architecture is based on the VAS. Physical memory is used by the OS to map values from file bytes to VAS addresses: process memory is VAS memory, not physical memory.

(In the following description, the terminology used will be particular to the Windows NT OS, but the concepts are applicable to other virtual memory operating systems)

When a process starts it has a 4GB VAS with no values. The -'s in the VAS line have no values. Using or setting values in such a VAS would cause a memory exception.

           0                                            4GB
VAS        |----------------------------------------------|

Then the application's EXE file is mapped into the VAS. Addresses in the process VAS are mapped to bytes in the exe file. The OS manages the mapping:

           0                                            4GB
VAS        |---vvvvvvv------------------------------------|
mapping        |-----|
file bytes     app.exe

The v's are values from bytes in the mapped file. Then, required DLL files are mapped (this includes custom libraries as well as system ones such as kernel32.dll and user32.dll):

           0                                            4GB
VAS        |---vvvvvvv----vvvvvv---vvvv-------------------|
mapping        |||||||    ||||||   ||||
file bytes     app.exe    kernel   user

The process then starts executing bytes in the exe file. However, the only way the process can use or set '-' values in its VAS is to ask the OS to map them to bytes from a file. A common way to use VAS memory in this way is to map it to the page file. The page file is a single file, but multiple distinct sets of contiguous bytes can be mapped into a VAS:

           0                                            4GB
VAS        |---vvvvvvv----vvvvvv---vvvv----vv---v----vvv--|
mapping        |||||||    ||||||   ||||    ||   |    |||
file bytes     app.exe    kernel   user   system_page_file

And different parts of the page file can map into the VAS of different processes:

           0                                            4GB
VAS 1      |---vvvv-------vvvvvv---vvvv----vv---v----vvv--|
mapping        ||||       ||||||   ||||    ||   |    |||
file bytes     app1 app2  kernel   user   system_page_file
mapping             ||||  ||||||   ||||       ||   |
VAS 2      |--------vvvv--vvvvvv---vvvv-------vv---v------|

Allocating memory via system calls such as C's malloc implicitly maps bytes of the page file into the VAS. However, a process can also explicitly map file bytes (see memory-mapped files).

[edit] References

• "Advanced Windows" by Jeffrey Richter, Microsoft Press