wmi Win32_PerfFormattedData_PerfOS_Memory reference for Network Programming in .NET with C# & Visual Basic .NET (VB.NET)

WMI class ' Win32_PerfFormattedData_PerfOS_Memory ' reference for C# and VB.NET

MOF Reference

[Description("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 on the computer.  Virtual memory consists of the 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."): ToInstance Amended, Amendment, locale(1033): ToInstance, DisplayName("Memory"): ToInstance Amended, genericperfctr: ToInstance]
class Win32_PerfFormattedData_PerfOS_Memory : Win32_PerfFormattedData
{
	[DisplayName("Available Bytes"): ToInstance Amended, Description("Available Bytes is the amount of physical memory, in bytes, available to processes running on the computer.  It is calculated by 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 subsequent processes from seeing data used by a previous process; Standby memory is memory that has been removed from a process' working set (its physical memory) on route to disk, but is still available to be recalled.  This counter displays the last observed value only; it is not an average. "): ToInstance Amended] uint64 AvailableBytes;
	[DisplayName("Available KBytes"): ToInstance Amended, Description("Available KBytes is the amount of physical memory available to processes running on the computer, in Kilobytes, rather than bytes as reported in Memory\\\\Available Bytes. It is calculated by adding the amount of space on the Zeroed, Free, and Stand by memory lists.  Free memory is ready for use; Zeroed memory are pages of memory filled with zeros to prevent later processes from seeing data used by a previous process; Standby memory is memory removed from a process' working set (its physical memory) on route to disk, but is still available to be recalled.  This counter displays the last observed value only; it is not an average. "): ToInstance Amended] uint64 AvailableKBytes;
	[DisplayName("Available MBytes"): ToInstance Amended, Description("Available MBytes is the amount of physical memory available to processes running on the computer, in Megabytes, rather than bytes as reported in Memory\\\\Available Bytes. It is calculated by adding the amount of space on the Zeroed, Free, and Stand by memory lists. Free memory is ready for use; Zeroed memory are pages of memory filled with zeros to prevent later processes from seeing data used by a previous process; Standby memory is memory removed from a process' working set (its physical memory) on route to disk, but is still available to be recalled.  This counter displays the last observed value only; it is not an average. "): ToInstance Amended] uint64 AvailableMBytes;
	[DisplayName("Cache Bytes"): ToInstance Amended, Description("Cache Bytes is the sum of the Memory\\\\System Cache Resident Bytes, Memory\\\\System Driver Resident Bytes, Memory\\\\System Code Resident Bytes, and Memory\\\\Pool Paged Resident Bytes counters.  This counter displays the last observed value only; it is not an average. "): ToInstance Amended] uint64 CacheBytes;
	[DisplayName("Cache Bytes Peak"): ToInstance Amended, Description("Cache Bytes Peak is 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. This counter displays the last observed value only; it is not an average. "): ToInstance Amended] uint64 CacheBytesPeak;
	[DisplayName("Cache Faults/sec"): ToInstance Amended, Description("Cache Faults/sec is 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). The file system cache is an area of physical memory that stores recently used pages of data for applications. Cache activity is a reliable indicator of most application I/O operations. This counter shows the number of faults, without regard for the number of pages faulted in each operation."): ToInstance Amended] uint32 CacheFaultsPersec;
	[DisplayName("Commit Limit"): ToInstance Amended, Description("Commit Limit is the amount of virtual memory that can be committed without having to extend the paging file(s).  It is measured in bytes. Committed memory is the physical memory which has space reserved on the disk paging files. There can be one paging file on each logical drive). If the paging file(s) are be expanded, this limit increases accordingly.  This counter displays the last observed value only; it is not an average."): ToInstance Amended] uint64 CommitLimit;
	[DisplayName("Committed Bytes"): ToInstance Amended, Description("Committed Bytes is the amount of committed virtual memory, in bytes. Committed memory is the physical memory which has space reserved on the disk paging file(s). There can be one or more paging files on each physical drive. This counter displays the last observed value only; it is not an average."): ToInstance Amended] uint64 CommittedBytes;
	[DisplayName("Demand Zero Faults/sec"): ToInstance Amended, Description("Demand Zero Faults/sec is 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 a security feature of Windows that prevent processes from seeing data stored by earlier processes that used the memory space. Windows maintains a list of zeroed pages to accelerate this process. This counter shows the number of faults, without regard to the number of pages retrieved 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."): ToInstance Amended] uint32 DemandZeroFaultsPersec;
	[DisplayName("Free System Page Table Entries"): ToInstance Amended, Description("Free System Page Table Entries is the number of page table entries not currently in used by the system.  This counter displays the last observed value only; it is not an average. "): ToInstance Amended] uint32 FreeSystemPageTableEntries;
	[DisplayName("Page Faults/sec"): ToInstance Amended, Description("Page Faults/sec is the average number of pages faulted per second. It is measured in number of pages faulted per second because only one page is faulted in each fault operation, hence 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 significant delays."): ToInstance Amended] uint32 PageFaultsPersec;
	[DisplayName("Page Reads/sec"): ToInstance Amended, Description("Page Reads/sec is the rate at which the disk was read to resolve hard page faults. It shows the number of reads 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 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 non-cached mapped memory files. Compare the value of Memory\\\\Pages Reads/sec to the value of Memory\\\\Pages Input/sec to determine the average number of pages read during each operation."): ToInstance Amended] uint32 PageReadsPersec;
	[DisplayName("Pages Input/sec"): ToInstance Amended, Description("Pages Input/sec is 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 the value of Memory\\\\Pages Input/sec to the value of  Memory\\\\Page Reads/sec to determine the average number of pages read into memory during each read operation."): ToInstance Amended] uint32 PagesInputPersec;
	[DisplayName("Pages Output/sec"): ToInstance Amended, Description("Pages Output/sec is the rate at which pages are written to disk to free up space in physical memory. Pages are written back to disk only if they are changed in physical memory, so they are likely to hold data, not code. A high rate of pages output might indicate a memory shortage. Windows writes more pages back to disk to free up space when physical memory is in short supply.  This counter shows the number of pages, and can be compared to other counts of pages, without conversion."): ToInstance Amended] uint32 PagesOutputPersec;
	[DisplayName("Pages/sec"): ToInstance Amended, Description("Pages/sec is 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) non-cached mapped memory files."): ToInstance Amended] uint32 PagesPersec;
	[DisplayName("Page Writes/sec"): ToInstance Amended, Description("Page Writes/sec is 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.  This counter displays the difference between the values observed in the last two samples, divided by the duration of the sample interval."): ToInstance Amended] uint32 PageWritesPersec;
	[DisplayName("% Committed Bytes In Use"): ToInstance Amended, Description("% Committed Bytes In Use is the ratio of Memory\\\\Committed Bytes to the Memory\\\\Commit Limit. Committed memory is the physical memory in use for which space has been reserved in the paging file should it need to 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). This counter displays the current percentage value only; it is not an average."): ToInstance Amended] uint32 PercentCommittedBytesInUse;
	[DisplayName("Pool Nonpaged Allocs"): ToInstance Amended, Description("Pool Nonpaged Allocs is the number of calls to allocate space in the nonpaged pool. The nonpaged pool is an area of system memory area for objects that cannot be written to disk, and must remain in physical memory as long as they are allocated.  It is measured in numbers of calls to allocate space, regardless of the amount of space allocated in each call.  This counter displays the last observed value only; it is not an average."): ToInstance Amended] uint32 PoolNonpagedAllocs;
	[DisplayName("Pool Nonpaged Bytes"): ToInstance Amended, Description("Pool Nonpaged Bytes is the size, in bytes, of the nonpaged pool, an area of system memory (physical memory used by the operating system) for objects that cannot be written to disk, but must remain in physical memory as long as they are allocated.  Memory\\\\Pool Nonpaged Bytes is calculated differently than Process\\\\Pool Nonpaged Bytes, so it might not equal Process\\\\Pool Nonpaged Bytes\\\\_Total.  This counter displays the last observed value only; it is not an average."): ToInstance Amended] uint64 PoolNonpagedBytes;
	[DisplayName("Pool Paged Allocs"): ToInstance Amended, Description("Pool Paged Allocs is the number of calls to allocate space in the paged pool. The paged pool is an area of system memory (physical memory used by the operating system) for objects that can be written to disk when they are not being used. It is measured in numbers of calls to allocate space, regardless of the amount of space allocated in each call.  This counter displays the last observed value only; it is not an average."): ToInstance Amended] uint32 PoolPagedAllocs;
	[DisplayName("Pool Paged Bytes"): ToInstance Amended, Description("Pool Paged Bytes is the size, in bytes, of the paged pool, an area of system memory (physical memory used by the operating system) for objects that can be written to disk when they are not being used.  Memory\\\\Pool Paged Bytes is calculated differently than Process\\\\Pool Paged Bytes, so it might not equal Process\\\\Pool Paged Bytes\\\\_Total. This counter displays the last observed value only; it is not an average."): ToInstance Amended] uint64 PoolPagedBytes;
	[DisplayName("Pool Paged Resident Bytes"): ToInstance Amended, Description("Pool Paged Resident Bytes is the current size, in bytes, of the paged pool. The paged pool is an area of system memory (physical memory used by the operating system) for objects that can be written to disk when they are not being used. Space used by the paged and nonpaged pools are taken from physical memory, so a pool that is too large denies memory space to processes. This counter displays the last observed value only; it is not an average."): ToInstance Amended] uint64 PoolPagedResidentBytes;
	[DisplayName("System Cache Resident Bytes"): ToInstance Amended, Description("System Cache Resident Bytes is the size, in bytes, of the 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 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. This counter displays the last observed value only; it is not an average. "): ToInstance Amended] uint64 SystemCacheResidentBytes;
	[DisplayName("System Code Resident Bytes"): ToInstance Amended, Description("System Code Resident Bytes is the size, in bytes of the 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. This counter displays the last observed value only; it is not an average."): ToInstance Amended] uint64 SystemCodeResidentBytes;
	[DisplayName("System Code Total Bytes"): ToInstance Amended, Description("System Code Total Bytes is the size, in bytes, of the 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 summing 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. This counter displays the last observed value only; it is not an average."): ToInstance Amended] uint64 SystemCodeTotalBytes;
	[DisplayName("System Driver Resident Bytes"): ToInstance Amended, Description("System Driver Resident Bytes is the size, in bytes, of the 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."): ToInstance Amended] uint64 SystemDriverResidentBytes;
	[DisplayName("System Driver Total Bytes"): ToInstance Amended, Description("System Driver Total Bytes is the size, in bytes, of the 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 paged to disk. It is a component of Memory\\\\System Code Total Bytes. This counter displays the last observed value only; it is not an average.  "): ToInstance Amended] uint64 SystemDriverTotalBytes;
	[DisplayName("Transition Faults/sec"): ToInstance Amended, Description("Transition Faults/sec is 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."): ToInstance Amended] uint32 TransitionFaultsPersec;
	[DisplayName("Write Copies/sec"): ToInstance Amended, Description("Write Copies/sec is the rate at which page faults are caused by attempts to write that have been satisfied by coping of 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 for the number of pages copied in each operation."): ToInstance Amended] uint32 WriteCopiesPersec;
};

Class properties:

Win32_PerfFormattedData_PerfOS_Memory.AvailableBytes
Win32_PerfFormattedData_PerfOS_Memory.AvailableKBytes
Win32_PerfFormattedData_PerfOS_Memory.AvailableMBytes
Win32_PerfFormattedData_PerfOS_Memory.CacheBytes
Win32_PerfFormattedData_PerfOS_Memory.CacheBytesPeak
Win32_PerfFormattedData_PerfOS_Memory.CacheFaultsPersec
Win32_PerfFormattedData_PerfOS_Memory.Caption
Win32_PerfFormattedData_PerfOS_Memory.CommitLimit
Win32_PerfFormattedData_PerfOS_Memory.CommittedBytes
Win32_PerfFormattedData_PerfOS_Memory.DemandZeroFaultsPersec
Win32_PerfFormattedData_PerfOS_Memory.Description
Win32_PerfFormattedData_PerfOS_Memory.FreeSystemPageTableEntries
Win32_PerfFormattedData_PerfOS_Memory.Frequency_Object
Win32_PerfFormattedData_PerfOS_Memory.Frequency_PerfTime
Win32_PerfFormattedData_PerfOS_Memory.Frequency_Sys100NS
Win32_PerfFormattedData_PerfOS_Memory.Name
Win32_PerfFormattedData_PerfOS_Memory.PageFaultsPersec
Win32_PerfFormattedData_PerfOS_Memory.PageReadsPersec
Win32_PerfFormattedData_PerfOS_Memory.PagesInputPersec
Win32_PerfFormattedData_PerfOS_Memory.PagesOutputPersec
Win32_PerfFormattedData_PerfOS_Memory.PagesPersec
Win32_PerfFormattedData_PerfOS_Memory.PageWritesPersec
Win32_PerfFormattedData_PerfOS_Memory.PercentCommittedBytesInUse
Win32_PerfFormattedData_PerfOS_Memory.PoolNonpagedAllocs
Win32_PerfFormattedData_PerfOS_Memory.PoolNonpagedBytes
Win32_PerfFormattedData_PerfOS_Memory.PoolPagedAllocs
Win32_PerfFormattedData_PerfOS_Memory.PoolPagedBytes
Win32_PerfFormattedData_PerfOS_Memory.PoolPagedResidentBytes
Win32_PerfFormattedData_PerfOS_Memory.SystemCacheResidentBytes
Win32_PerfFormattedData_PerfOS_Memory.SystemCodeResidentBytes
Win32_PerfFormattedData_PerfOS_Memory.SystemCodeTotalBytes
Win32_PerfFormattedData_PerfOS_Memory.SystemDriverResidentBytes
Win32_PerfFormattedData_PerfOS_Memory.SystemDriverTotalBytes
Win32_PerfFormattedData_PerfOS_Memory.Timestamp_Object
Win32_PerfFormattedData_PerfOS_Memory.Timestamp_PerfTime
Win32_PerfFormattedData_PerfOS_Memory.Timestamp_Sys100NS
Win32_PerfFormattedData_PerfOS_Memory.TransitionFaultsPersec
Win32_PerfFormattedData_PerfOS_Memory.WriteCopiesPersec

WMI is a huge subject, so therefore it is practically impossible to provide a comprehensive example program that covers anything. However, the book �Network programming in .NET� (Buy at Amazon UK) (Buy at Amazon US) covers a much wider scope of WMI, and explains how to leverage it to access the bounty of information held within this vast, yet simple object model.

Articles

Contact us

Please use FireFox to view this page

WMI class ' Win32_PerfFormattedData_PerfOS_Memory ' reference for C# and VB.NET

MOF Reference

Class properties: