Virtual Address Space (32bits)


Menigeen raakt in verwarring als het gaat om de wijze waarop een operating systeem omgaat met het geheugen en de gevolgen die zichtbaar zijn wanneer er te weinig geheugenruimte wordt gesignaleerd. In dit artikel een uitleg over hoe een en ander in zijn werk gaat.

In de pc heb je te maken met twee soorten geheugens. Fysiek geheugen en virtueel geheugen.

Fysiek geheugen komt in verschillende vormen: on-chip cache, off-chip cache en systeem geheugen. Het Operating Systeem (OS) ziet deze als cache geheugen. Ook het bestand pagefile.sys is een soort cache geheugen, en dit bestand verblijft op de harddisk.
Het werkgeheugen (RAM) wordt geadresseerd met hex adressen en bij een 4 GB geheugen loopt dit van adres 0x0000 0000 tot 0xFFFF FFFF (0 tot 2^32 -1)
In principe is bij een 32-bits operating system de fysieke geheugenruimte ingedeeld in twee gedeeltes van 2 GB, waarbij dus de helft is gereserveerd voor het operating system (kernel, dll, user, etc) en de andere 2 GB voor het verwerken van gebruikersbestanden. Het werkgeheugen (RAM) krijgt zijn informatie aangeleverd door de informatie uit het virtuele geheugen.

Virtueel geheugen.
Wanneer de computer opstart, ontstaan er processen. Ieder proces heeft een nummer -een proces-ID- en krijgt een 4 GB virtuele adresseringsruimte toebedeeld (en dat is dus geen geheugenruimte!) met een adres-hex-waarde van 0x00000000 tot 0xFFFFFFFF minus 1.

Deze adressen tezamen worden ‘virtual address space’ (VAS) genoemd. Kortom maximaal 4.194.303 geheugenplaatsen met de waarde nul of een. De waarde die een geheugenplaats krijgt, wordt verkregen uit de waarde zoals die in een bestand aanwezig is. Iedere keer als er een nieuw proces wordt gestart, krijgt het proces-ID een nieuwe VAS toebedeeld die 4 GB groot is. Een proces dat wordt gestart met een bestandsgrootte van 32 kb neemt dus in principe 32000 verschillende adresposities in beslag met ieder een eigen waarde. Nogmaals: 4 GB virtuele adressen is niet gelijk aan de mogelijk aanwezige 4 GB werkgeheugen.

Voorbeeld:
Wanneer er een applicatie op een 32-bit Os wordt gestart, krijgt het proces een 4 GB VAS. De waarde van de bytes in de VAS is per definitie geen, anders ontstaat er een “memory exception”.

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

Daarna wordt de de applicatie.exe gemapped in de VAS

0 |---------------vvvvvvvvvv----------------------------------------------------| 4 GB

De adressen van het proces worden door het OS gehaald uit het exe-bestand en de v-tjes vertegenwoordigen de waarde zoals het bestand aangeeft (0 of 1)
Dan volgen de gewenste DLL bestanden en systeembestanden zoals kernel32.dll en user32.dll

0 |--------------------vvvvvvv------vvvvv-----vvvvvvvv---------------------------| 4GB
VAS MAPPING FILE BYTES |||||||      |||||     ||||||||
0 |--------------------app1.exe-----kernel-----user.dll--------------------------| 4GB

Het proces begint dan met met uitvoeren van de bytes uit het bestand. Echter de enige manier om om de waarde van de VAS te wijzigen, is er een waarbij het OS de waarde van de byte uit een file overbrengt in de VAS. Een gebruikelijke manier om de VAS te voorzien van waarden is de waardes te mappen met die uit de pagefile.sys. De pagefile is een enkelvoudig bestand, maar met meervoudige sets van aaneengesloten bytes die kunnen worden gemapped met de VAS. Daarbij kunnen verschillende delen van de pagefile gemapped worden met VAS waarden van verschillende processen.

0 |-------VVVVV----------------------vvvvv-----vvvvvvvv--------VV---VV----VVV-----| 4GB
           ||||                      |||||     |||||||         ||   ||    |||
0 |--------APP1.EXE----app2.exe-----kernel-----user.dll--------SYSEM PAGE FILE----| 4GB
VAS MAPPING FILE BYTES  |||||||     ||||      ||||||||           |          |
0 |--------------------vvvvvvv------vvvvv-----vvvvvvvv-----------V----------V-----| 4GB

Bij een 32-bit Windows installatie is er ten principale slechts 2 GB VAS ter beschikking voor processen voor eigen gebruik en de andere 2 GB worden gebruikt door het operating system.

Bij een 64-bit windows installatie en wanneer er een 32-bits executable gelinked is aan de optie /LARGEADDRESSAWARE:YES dan alleen heeft deze executable toegang tot het gebruik maken van de 4 GB adresruimte van de VAS.
Daarom staat er in de fsx.cfg een optie: HIGHMEM=1
Zonder deze optie is de adressering beperkt tot 2 GB (0x 0000 0000 tot 0x 7FFFF FFF)

Bij 64-bit processen en met de /LARGEADDRESSAWARE:YES optie op YES heeft de executable toegang tot 8 TB adresruimte; wanneer de /LARGEADDRESSAWARE:NO is ingesteld (en dat is default), dan is de adresseringsruimte beperkt tot 2 GB.

De wijze waarop de inhoud van de VAS overgebracht wordt naar het werkgeheugen noemen we “paging”. Dit is het ‘instrument’ dat er voor zorgt dat niet gebruikte bytes uit het werkgeheugen worden verplaatst naar de page file. De page table houdt bij welke adres (met zijn waarde) geplaatst moet worden op een nader te bepalen hex adres in het werkgeheugen.

Zie de VAS als een grote schoenendoos voor te ontvangen post met voor iedere afzender (proces) de mogelijkheid om 4 miljoen verschillende adressen te kennen. De tweede afzender krijgt dezelfde faciliteit. Enzovoorts. De processor haalt uit de VAS de post op die hij nodig heeft en de locatie waar de post verblijft (of in het werkgeheugen of in een offline cache of in een pagefile.sys) , staat genoteerd in het postboek (page table).

Address Space Monitor (32bits)


Address Space Monitor is a simple utility to monitor a process’ use of its address space.  To begin monitoring a process, choose the “Process|Attach …” menu option and type in the process id of the process to be monitored. The “Attach to process” dialog box now features a process browser so that you can select the process by name.

Alternatively you can choose to spawn a new process. If you select the “Process|Run…” menu option you will be presented with the “Run” dialog box. From here you can browse for the executable file for the process you wish to start and the initial working directory for the process. You can also enter in any required command line arguments.

While monitoring a process, the display is split into three sections.

The top section shows the address space of the process in a gauge format, from low addresses (close to zero) on the left, rotating clockwise to high addresses (2GB for 32-bit processes, 8TB for 64-bit processes) on the right.

Free address space is shown in green, reserved addresses in yellow and used (committed) memory regions in red.

The next section of the display shows the largest free regions of address space as colored ellipses in descending order of size. The full width of the display represents a quarter of the total address space for the process (about 512MB for 32-bit processes, about 2TB for 64-bit processes) and large regions are shown as half an ellipse covering the full width of the display even if they exceed half the total address space.

The regions are colored according to their upper address so that they can be tracked as their lower parts are used up. Low regions start from yellow, going through magenta at half way, to cyan at the upper end of the address space.

The final section has some textual summaries for the address space.

The first number is the total amount of committed address space for the whole process,  the second number is the total amount of reserved address space for the process, the third number is the total amount of free memory and the final number is the size of the largest free address space region.

For committed and reserved regions these totals may be larger than what you might expect from looking at other memory analysis tools as all address space is counted, including mapped files and shared memory regions, rather than just regions which are mapped to physical memory or swap file space.

The utility has most use for 32-bit processes as 64-bit process tend to be dominated by a very large (only fractionally smaller that 8TB) region of free address space from the 2GB boundary upwards.

Address Space Monitor now supports recording both single snapshots of a process’ address space as well as recordings of a process’ address space over time. A snapshot can be recorded through the “File|Save as…” menu options, and redisplayed through the “File|Open…” option.

A recording can either be started through the “File|Record…” option or, when creating a new process, by selecting the “Record” check box in the “Run” dialog box and browsing for the name of a file to record. In both cases the recording will stop when the process being monitored exits. While recording the “File|Record…” menu option will display a tick icon. The recording can be halted manually by reselecting the “File|Record…” menu option while the menu option displays a tick mark.

The utility can be downloaded from HERE

Source: Charles Bailey.