Memory Object
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 random-access memory (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, a symptom of a memory shortage, can cause delays which interfere with all system processes.
| Counter Name | Description | Counter Type |
|---|---|---|
| % Committed Bytes In Use | shows the ratio of Memory\ Committed Bytes to the Memory\ Commit Limit. Committed memory is physical memory in use for which space has been reserved in the paging file 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. | PERF_RAW_FRACTION |
| Available Bytes | Shows the amount of physical memory, in bytes, available to processes running on the computer. It is calculated by summing adding the amount of space on the zeroed, free, and standby memory lists. Free memory is ready for use; zeroed memory consists of pages of memory filled with zeros to prevent later processes from seeing data used by a previous process; standby memory is memory that has been removed from a process's working set (its physical memory) en route to disk but is still available to be recalled. | PERF_COUNTER_RAWCOUNT |
| Available KBytes | Shows the amount of memory available to processes running on the computer, in kilobytes rather than bytes, as reported by Memory\Available Bytes. | PERF_COUNTER_RAWCOUNT |
| Available MBytes | Shows the amount of memory available to processes running on the computer, in megabytes rather than bytes, as reported by Memory\Available Bytes. | PERF_COUNTER_RAWCOUNT |
| 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. | PERF_COUNTER_RAWCOUNT |
| Cache Bytes Peak | Shows the maximum number of bytes used by the file system cache since the system was last restarted. This might be larger than the current size of the cache. | PERF_COUNTER_RAWCOUNT |
| Cache Faults/sec | hows the rate at which faults occur when a page sought in the file system cache is not found and must be retrieved from elsewhere in memory (a soft fault) or from disk (a hard fault). This counter shows the number of faults, without regard for the number of pages faulted in each operation. | PERF_COUNTER_COUNTER |
| 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 which has space reserved on the disk paging files. There can be one or more paging files on each physical drive. If the paging file(s) are expanded, this limit increases accordingly. | PERF_COUNTER_RAWCOUNT |
| Committed Bytes | Shows the amount of committed virtual memory, in bytes. | PERF_COUNTER_RAWCOUNT |
| Demand Zero Faults/sec | Shows the rate at which a zeroed page is required to satisfy the fault. Zeroed pages, pages emptied of previously stored data and filled with zeros, are security features in Windows 2000 that prevent processes from seeing data stored by earlier processes that used the memory space. Windows 2000 maintains a list of zeroed pages to accelerate this process. This counter shows numbers of faults, without regard to the numbers of pages retrieved to satisfy the fault. | PERF_COUNTER_COUNTER |
| Free System Page Table Entries | Shows the number of page table entries not currently in use by the system. | PERF_COUNTER_RAWCOUNT |
| Page Faults/sec | Shows the average number of pages faulted per second. It is measured in numbers of pages faulted; because only one page is faulted in each fault operation, this is also equal to the number of page fault operations. 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, which require disk access, can cause delays. | PERF_COUNTER_COUNTER |
| Page Reads/sec | Shows the rate at which the disk is read to resolve hard page faults. It 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 is not in its working set or elsewhere in physical memory, and must be retrieved from disk. This counter is a primary indicator of 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. | PERF_COUNTER_COUNTER |
| Page Writes/sec | Shows the rate at which pages are 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. | PERF_COUNTER_COUNTER |
| Pages Input/sec | Shows the rate at which pages are read from disk to resolve hard page faults. Hard page faults occur when a process refers to a page in virtual memory that is not in its working set or elsewhere in physical memory, and must be retrieved from disk. 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 | PERF_COUNTER_COUNTER |
| Pages Output/sec | Shows the rate at which pages are written to disk to free up space in physical memory. A high rate of pages output might indicate a memory shortage. Windows 2000 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. | PERF_COUNTER_COUNTER |
| Pages/sec | Shows the rate at which pages are read from or written to disk to resolve hard page faults. This counter is a primary indicator of the kinds of faults that cause system-wide delays. It is the sum of Memory\ Pages Input/sec and Memory\ Pages Output/sec. It is counted in numbers of pages, so it can be compared to other counts of pages, such as Memory\ Page Faults/sec, without conversion. It includes pages retrieved to satisfy faults in the file system cache (usually requested by applications) and noncached mapped memory files. | PERF_COUNTER_COUNTER |
| Pool Nonpaged Allocs | Shows the number of calls to allocate space in the nonpaged pool. It is measured in numbers of calls to allocate space, regardless of the amount of space allocated in each call. | PERF_COUNTER_RAWCOUNT |
| Pool Nonpaged Bytes | Shows the size, in bytes, of the nonpaged pool. Memory\ Pool Nonpaged Bytes is calculated differently than Process\ Pool Nonpaged Bytes, so it might not equal Process(_Total )\ Pool Nonpaged Bytes. | PERF_COUNTER_RAWCOUNT |
| Pool Paged Allocs | Shows the number of calls to allocate space in the paged pool. It is measured in numbers of calls to allocate space, regardless of the amount of space allocated in each call. | PERF_COUNTER_RAWCOUNT |
| Pool Paged Bytes | Shows the size, in bytes, of the paged pool. Memory\ Pool Paged Bytes is calculated differently than Process\ Pool Paged Bytes, so it might not equal Process(_Total )\ Pool Paged Bytes. | PERF_COUNTER_RAWCOUNT |
| Pool Paged Resident Bytes | Shows the current 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. | PERF_COUNTER_RAWCOUNT |
| 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 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 Memory\ System Code Resident Bytes which represents all pageable operating system code that is currently in physical memory. | PERF_COUNTER_RAWCOUNT |
| 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 Memory\ System Code Total Bytes, which also includes operating system code on disk. Memory\ System Code Resident Bytes (and Memory\ System Code Total Bytes) does not include code that must remain in physical memory and cannot be written to disk. | PERF_COUNTER_RAWCOUNT |
| 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 and cannot be written to disk. | PERF_COUNTER_RAWCOUNT |
| System Driver Resident Bytes | Shows the size, in bytes, of pageable physical memory being used by device drivers. It is the working set (physical memory area) of the drivers. This value is a component of Memory\ System Driver Total Bytes, which also includes driver memory that has been written to disk. Neither Memory\ System Driver Resident Bytes nor Memory\ System Driver Total Bytes includes memory that cannot be written to disk. | PERF_COUNTER_RAWCOUNT |
| 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 (Memory\ System Driver Resident Bytes) and code and data written to disk. It is a component of Memory\ System Code Total Bytes. | PERF_COUNTER_RAWCOUNT |
| Transition Faults/sec | Shows the rate at which page faults are resolved by recovering pages that were being used by another process sharing the page, or were on the modified page list or the standby list, or were being written to disk at the time of the page fault. The pages were recovered without additional disk activity. Transition faults are counted in numbers of faults; because only one page is faulted in each operation, it is also equal to the number of pages faulted. | PERF_COUNTER_COUNTER |
| Write Copies/sec | Shows the rate at which page faults are caused by attempts to write that have been 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. | PERF_COUNTER_COUNTER |
See also
- Finding Memory Bottlenecks
- Finding Cache Bottlenecks
.