Memory Object
Applies To: Windows Server 2003, Windows Server 2003 R2, Windows Server 2003 with SP1, Windows Server 2003 with SP2
The Memory performance object consists of counters that describe the behavior of physical and virtual memory on the computer. Physical memory is the amount of RAM on the computer. Virtual memory consists of space in physical memory and on disk. Many of the memory counters monitor paging, which is the movement of pages of code and data between disk and physical memory. Excessive paging is a symptom of a memory shortage and can cause delays that interfere with all system processes.
| Counter Name | Description | Counter Type |
|---|---|---|
% Committed Bytes In Use |
Shows the ratio of Committed Bytes to the Commit Limit. Committed memory is physical memory in use, for which space has been reserved in the paging file(s) so that it can be written to disk. The commit limit is determined by the size of the paging file. If the paging file is enlarged, the commit limit increases, and the ratio is reduced. |
|
Available Bytes |
Shows the amount of physical memory, in bytes, immediately available for allocation to a process or for system use. It is equal to the sum of memory assigned to the standby (cached), free, and zero page lists. |
|
Available KBytes |
Shows the amount of physical memory, in Kilobytes, immediately available for allocation to a process or for system use. It is equal to the sum of memory assigned to the standby (cached), free, and zero page lists. |
|
Available MBytes |
Shows the amount of physical memory, in Megabytes, immediately available for allocation to a process or for system use. It is equal to the sum of memory assigned to the standby (cached), free, and zero page lists. |
|
Cache Bytes |
Shows the sum of the values of System Cache Resident Bytes, System Driver Resident Bytes, System Code Resident Bytes, and Pool Paged Resident Bytes. |
|
Cache Bytes Peak |
Shows the maximum number of bytes used by the file system cache since the system was last started. This might be larger than the current size of the cache. |
|
Cache Faults/sec |
Shows the rate, in incidents per second, at which faults occured when a page that was sought in the file system cache was not found and was be retrieved either from elsewhere in memory (a soft fault) or from disk (a hard fault). This counter shows the total number of faults, without regard for the number of pages faulted in each operation. |
|
Commit Limit |
Shows the amount of virtual memory, in bytes, that can be committed without having to extend the paging file(s). Committed memory is physical memory that has space reserved on the disk paging file(s). There can be one or more paging files on each physical drive. If the paging file(s) are expanded, this limit increases accordingly. |
|
Committed Bytes |
Shows the amount of committed virtual memory, in bytes. |
|
Demand Zero Faults/sec |
Shows the average rate, in incidents per second, at which page faults required a zeroed page to satisfy the fault. This counter displays the difference between the values observed in the last two samples, divided by the duration of the sample interval. Zeroed pages (pages emptied of previously stored data and filled with zeroes) prevent processes from seeing data stored by earlier processes that used the same memory space. This counter displays the number of faults, without regard to the number of pages retrieved to satisfy the fault. |
|
Free System Page Table Entries |
Shows the number of page table entries not in use by the system. |
|
Page Faults/sec |
Shows the average number of pages faulted per second, which is equal to the number of page fault operations because only one page is faulted in each fault operation. This counter includes both hard faults (those that require disk access) and soft faults (where the faulted page is found elsewhere in physical memory). Most processors can handle large numbers of soft faults without significant consequence. However, hard faults can cause delaysbecause they require disk access.. |
|
Page Reads/sec |
Shows the rate, in incidents per second, at which the disk was read to resolve hard page faults. This counter shows numbers of read operations, without regard to the number of pages retrieved in each operation. Hard page faults occur when a process references a page in virtual memory that must be retrieved from disk because it is not in its working set or elsewhere in physical memory. This counter is a primary indicator for the kinds of faults that cause system-wide delays. It includes read operations to satisfy faults in the file system cache (usually requested by applications) and in noncached mapped memory files. Compare the value of Page Reads/sec to the value of Pages Input/sec to find an average of how many pages were read during each read operation. |
|
Page Writes/sec |
Shows the rate, in incidents per second, at which pages were written to disk to free up space in physical memory. Pages are written to disk only if they are changed while in physical memory, so they are likely to hold data, not code. This counter shows write operations, without regard to the number of pages written in each operation. |
|
Pages Input/sec |
Shows the rate, in incidents per second, at which pages were read from disk to resolve hard page faults. Hard page faults occur when a process refers to a page in virtual memory that must be retrieved from disk because it is not in its working set or elsewhere in physical memory. When a page is faulted, the system tries to read multiple contiguous pages into memory to maximize the benefit of the read operation. Compare Pages Input/sec to Page Reads/sec to find the average number of pages read into memory during each read operation |
|
Pages Output/sec |
Shows the rate, in incidents per second, at which pages were written to disk to free up space in physical memory. A high rate of pages output might indicate a memory shortage. The Windows Server 2003 family writes more pages back to disk to free up space when physical memory is in short supply. This counter shows numbers of pages, and can be compared to other counts of pages without conversion. |
|
Pages/sec |
Shows the rate, in incidents per second, at which pages were read from or written to disk to resolve hard page faults. This counter is a primary indicator for the kinds of faults that cause system-wide delays. It is the sum of Pages Input/sec and Pages Output/sec. It is counted in numbers of pages, so it can be directly compared to other counts of pages such as Page Faults/sec. It includes pages retrieved to satisfy faults in the file system cache (usually requested by applications) and noncached mapped memory files. |
|
Pool Nonpaged Allocs |
Shows the number of calls to allocate space in the nonpaged pool. This counter is measured in numbers of calls to allocate space, regardless of the amount of space allocated in each call. |
|
Pool Nonpaged Bytes |
Shows the size, in bytes, of the nonpaged pool. Pool Nonpaged Bytes is calculated differently than Process\Pool Nonpaged Bytes, so it might not equal Process(_Total )\Pool Nonpaged Bytes. |
|
Pool Paged Allocs |
Shows the number of calls to allocate space in the paged pool. This counter is measured in numbers of calls to allocate space, regardless of the amount of space allocated in each call. |
|
Pool Paged Bytes |
Shows the size, in bytes, of the paged pool. Pool Paged Bytes is calculated differently than Process\Pool Paged Bytes, so it might not equal Process(_Total )\Pool Paged Bytes. |
|
Pool Paged Resident Bytes |
Shows the size, in bytes, of the paged pool. Space used by the paged and nonpaged pools is taken from physical memory, so a pool that is too large denies memory space to processes. |
|
System Cache Resident Bytes |
Shows the size, in bytes, of pageable operating system code in the file system cache. This value includes only current physical pages and does not include any virtual memory pages that are not currently resident. It does not equal the System Cache value shown in Task Manager. As a result, this value may be smaller than the actual amount of virtual memory in use by the file system cache. This value is a component of System Code Resident Bytes that represents all pageable operating system code that is currently in physical memory. |
|
System Code Resident Bytes |
Shows the size, in bytes, of operating system code currently in physical memory that can be written to disk when not in use. This value is a component of System Code Total Bytes, which also includes operating system code on disk. System Code Resident Bytes (and System Code Total Bytes) does not include code that must remain in physical memory. |
|
System Code Total Bytes |
Shows the size, in bytes, of pageable operating system code currently in virtual memory. It is a measure of the amount of physical memory being used by the operating system that can be written to disk when not in use. This value is calculated by adding the bytes in Ntoskrnl.exe, Hal.dll, the boot drivers, and file systems loaded by Ntldr/osloader. This counter does not include code that must remain in physical memory. |
|
System Driver Resident Bytes |
Shows the size, in bytes, of pageable physical memory being used by device drivers. The counter is the working set (physical memory area) of the drivers. This value is a component of System Driver Total Bytes, which also includes driver memory that has been written to disk. Neither System Driver Resident Bytes nor System Driver Total Bytes includes memory that cannot be written to disk. |
|
System Driver Total Bytes |
Shows the size, in bytes, of pageable virtual memory currently being used by device drivers. Pageable memory can be written to disk when it is not being used. It includes physical memory (System Driver Resident Bytes) and code and data written to disk. This counter is a component of System Code Total Bytes. |
|
Transition Faults/sec |
Shows the rate, in incidents per second, at which page faults were resolved by recovering pages without additional disk activity, including pages that were being used by another process sharing the page, or that were on the modified page list or the standby list, or that were being written to disk at the time of the page fault. This counter is also equal to the number of pages faulted because only one page is faulted in each operation. |
|
Write Copies/sec |
Shows the rate, in incidents per second, at which page faults were caused by attempts to write that were satisfied by copying the page from elsewhere in physical memory. This is an economical way of sharing data since pages are only copied when they are written to; otherwise, the page is shared. This counter shows the number of copies, without regard to the number of pages copied in each operation. |