| 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 |
Nenhum comentário:
Postar um comentário