snmp informant

MRTGでWindowsのリソースをグラフ化するのに使用したモジュールのメモ書き

Informant Systems, Inc.
http://www.snmp-informant.com/

SNMP Informant-Premiumは有償ですがSNMP Informant-STDは無償で使用することができます

SNMP Informant-STD　Downloads
http://www.snmp-informant.com/downloads.htm#SNMP_Informant_-_Freeware_Products

ちなみにこれ以外にもマザーボートの情報も得られるSNMP Informant-MBM (Motherboard Monitor)も利用することができます

informant-std-16.zipをdownloadして解凍、informant-std-16.exeを実行してインストールするだけで利用できます

試しにシステム稼働時間を取得してみます

$ snmpwalk -v 1 -c public 192.168.1.200 1.3.6.1.4.1.9600.1.1.6
SNMPv2-SMI::enterprises.9600.1.1.6.1.0 = Gauge32: 737283
End of MIB
$

737283秒なので8日ですね

利用できるOID

<strong>SNMP Informant-Standard - OID Tree Listing</strong>

--standard(1.3.6.1.4.1.9600.1.1)
  |
  +--logicalDiskTable(1)
  |  |
  |  +--logicalDiskEntry(1) [lDiskInstance]
  |     |
  |     +-- r-n InstanceName lDiskInstance(1)
  |     +-- r-n Gauge32      lDiskPercentDiskReadTime(2)
  |     +-- r-n Gauge32      lDiskPercentDiskTime(3)
  |     +-- r-n Gauge32      lDiskPercentDiskWriteTime(4)
  |     +-- r-n Gauge32      lDiskPercentFreeSpace(5)
  |     +-- r-n Gauge32      lDiskPercentIdleTime(6)
  |     +-- r-n Gauge32      lDiskAvgDiskQueueLength(7)
  |     +-- r-n Gauge32      lDiskAvgDiskReadQueueLength(8)
  |     +-- r-n Gauge32      lDiskAvgDiskWriteQueueLength(9)
  |     +-- r-n Gauge32      lDiskAvgDiskSecPerRead(10)
  |     +-- r-n Gauge32      lDiskAvgDiskSecPerTransfer(11)
  |     +-- r-n Gauge32      lDiskAvgDiskSecPerWrite(12)
  |     +-- r-n Gauge32      lDiskCurrentDiskQueueLength(13)
  |     +-- r-n Gauge32      lDiskDiskBytesPerSec(14)
  |     +-- r-n Gauge32      lDiskDiskReadBytesPerSec(15)
  |     +-- r-n Gauge32      lDiskDiskReadsPerSec(16)
  |     +-- r-n Gauge32      lDiskDiskTransfersPerSec(17)
  |     +-- r-n Gauge32      lDiskDiskWriteBytesPerSec(18)
  |     +-- r-n Gauge32      lDiskDiskWritesPerSec(19)
  |     +-- r-n Gauge32      lDiskFreeMegabytes(20)
  |     +-- r-n Gauge32      lDiskSplitIOPerSec(21)
  |
  +--memory(2)
  |  |
  |  +-- r-n Gauge32   memoryAvailableBytes(1)
  |  +-- r-n Gauge32   memoryAvailableKBytes(2)
  |  +-- r-n Gauge32   memoryAvailableMBytes(3)
  |  +-- r-n Gauge32   memoryCommittedBytes(4)
  |  +-- r-n Gauge32   memoryCacheBytes(5)
  |  +-- r-n Gauge32   memoryCacheBytesPeak(6)
  |  +-- r-n Gauge32   memoryPageFaultsPerSec(7)
  |  +-- r-n Gauge32   memoryPagesInputPerSec(8)
  |  +-- r-n Gauge32   memoryPagesOutputPerSec(9)
  |  +-- r-n Gauge32   memoryPagesPerSec(10)
  |  +-- r-n Gauge32   memoryPoolNonpagedBytes(11)
  |  +-- r-n Gauge32   memoryPoolPagedBytes(12)
  |  +-- r-n Gauge32   memoryPoolPagedResidentBytes(13)
  |  +-- r-n Gauge32   memorySystemCacheResidentBytes(14)
  |  +-- r-n Gauge32   memorySystemCodeResidentBytes(15)
  |  +-- r-n Gauge32   memorySystemCodeTotalBytes(16)
  |  +-- r-n Gauge32   memorySystemDriverResidentBytes(17)
  |  +-- r-n Gauge32   memorySystemDriverTotalBytes(18)
  |  +-- r-n Gauge32   memoryCommittedKBytes(19)
  |  +-- r-n Gauge32   memoryCacheKBytes(20)
  |  +-- r-n Gauge32   memoryCacheKBytesPeak(21)
  |  +-- r-n Gauge32   memoryPoolNonpagedKBytes(22)
  |  +-- r-n Gauge32   memoryPoolPagedKBytes(23)
  |  +-- r-n Gauge32   memoryPoolPagedResidentKBytes(24)
  |  +-- r-n Gauge32   memorySystemCacheResidentKBytes(25)
  |  +-- r-n Gauge32   memorySystemCodeResidentKBytes(26)
  |  +-- r-n Gauge32   memorySystemCodeTotalKBytes(27)
  |  +-- r-n Gauge32   memorySystemDriverResidentKBytes(28)
  |  +-- r-n Gauge32   memorySystemDriverTotalKBytes(29)
  |  +-- r-n Gauge32   memoryCommittedMBytes(30)
  |  +-- r-n Gauge32   memoryCacheMBytes(31)
  |  +-- r-n Gauge32   memoryCacheMBytesPeak(32)
  |  +-- r-n Gauge32   memoryPoolNonpagedMBytes(33)
  |  +-- r-n Gauge32   memoryPoolPagedMBytes(34)
  |  +-- r-n Gauge32   memoryPoolPagedResidentMBytes(35)
  |  +-- r-n Gauge32   memorySystemCacheResidentMBytes(36)
  |  +-- r-n Gauge32   memorySystemCodeResidentMBytes(37)
  |  +-- r-n Gauge32   memorySystemCodeTotalMBytes(38)
  |  +-- r-n Gauge32   memorySystemDriverResidentMBytes(39)
  |  +-- r-n Gauge32   memorySystemDriverTotalMBytes(40)
  |
  +--networkInterfaceTable(3)
  |  |
  |  +--networkInterfaceEntry(1) [netInstance]
  |     |
  |     +-- r-n InstanceName netInstance(1)
  |     +-- r-n Gauge32      netBytesReceivedPerSec(2)
  |     +-- r-n Gauge32      netBytesSentPerSec(3)
  |     +-- r-n Gauge32      netBytesTotalPerSec(4)
  |     +-- r-n Gauge32      netCurrentBandwidth(5)
  |     +-- r-n Gauge32      netOutputQueueLength(6)
  |     +-- r-n Gauge32      netPacketsOutboundDiscarded(7)
  |     +-- r-n Gauge32      netPacketsOutboundErrors(8)
  |     +-- r-n Gauge32      netPacketsReceivedDiscarded(9)
  |     +-- r-n Gauge32      netPacketsReceivedErrors(10)
  |     +-- r-n Gauge32      netPacketsReceivedUnknown(11)
  |     +-- r-n Gauge32      netPacketsReceivedPerSec(12)
  |     +-- r-n Gauge32      netPacketsSentPerSec(13)
  |     +-- r-n Gauge32      netPacketsPerSec(14)
  |
  +--objects(4)
  |  |
  |  +-- r-n Gauge32   objectsProcesses(1)
  |  +-- r-n Gauge32   objectsThreads(2)
  |
  +--processorTable(5)
  |  |
  |  +--processorEntry(1) [cpuInstance]
  |     |
  |     +-- r-n InstanceName cpuInstance(1)
  |     +-- r-n Gauge32      cpuPercentDPCTime(2)
  |     +-- r-n Gauge32      cpuPercentInterruptTime(3)
  |     +-- r-n Gauge32      cpuPercentPrivilegedTime(4)
  |     +-- r-n Gauge32      cpuPercentProcessorTime(5)
  |     +-- r-n Gauge32      cpuPercentUserTime(6)
  |     +-- r-n Gauge32      cpuAPCBypassesPerSec(7)
  |     +-- r-n Gauge32      cpuDPCBypassesPerSec(8)
  |     +-- r-n Gauge32      cpuDPCRate(9)
  |     +-- r-n Gauge32      cpuDPCsQueuedPerSec(10)
  |     +-- r-n Gauge32      cpuInterruptsPerSec(11)
  |
  +--system(6)
     |
     +-- r-n Gauge32   systemSystemUpTime(1)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

<strong>SNMP Informant-Standard - OID Tree Listing</strong>

--standard(1.3.6.1.4.1.9600.1.1)

+--logicalDiskTable(1)

| |

| +--logicalDiskEntry(1) [lDiskInstance]

| |

| +-- r-n InstanceName lDiskInstance(1)

| +-- r-n Gauge32 lDiskPercentDiskReadTime(2)

| +-- r-n Gauge32 lDiskPercentDiskTime(3)

| +-- r-n Gauge32 lDiskPercentDiskWriteTime(4)

| +-- r-n Gauge32 lDiskPercentFreeSpace(5)

| +-- r-n Gauge32 lDiskPercentIdleTime(6)

| +-- r-n Gauge32 lDiskAvgDiskQueueLength(7)

| +-- r-n Gauge32 lDiskAvgDiskReadQueueLength(8)

| +-- r-n Gauge32 lDiskAvgDiskWriteQueueLength(9)

| +-- r-n Gauge32 lDiskAvgDiskSecPerRead(10)

| +-- r-n Gauge32 lDiskAvgDiskSecPerTransfer(11)

| +-- r-n Gauge32 lDiskAvgDiskSecPerWrite(12)

| +-- r-n Gauge32 lDiskCurrentDiskQueueLength(13)

| +-- r-n Gauge32 lDiskDiskBytesPerSec(14)

| +-- r-n Gauge32 lDiskDiskReadBytesPerSec(15)

| +-- r-n Gauge32 lDiskDiskReadsPerSec(16)

| +-- r-n Gauge32 lDiskDiskTransfersPerSec(17)

| +-- r-n Gauge32 lDiskDiskWriteBytesPerSec(18)

| +-- r-n Gauge32 lDiskDiskWritesPerSec(19)

| +-- r-n Gauge32 lDiskFreeMegabytes(20)

| +-- r-n Gauge32 lDiskSplitIOPerSec(21)

+--memory(2)

| |

| +-- r-n Gauge32 memoryAvailableBytes(1)

| +-- r-n Gauge32 memoryAvailableKBytes(2)

| +-- r-n Gauge32 memoryAvailableMBytes(3)

| +-- r-n Gauge32 memoryCommittedBytes(4)

| +-- r-n Gauge32 memoryCacheBytes(5)

| +-- r-n Gauge32 memoryCacheBytesPeak(6)

| +-- r-n Gauge32 memoryPageFaultsPerSec(7)

| +-- r-n Gauge32 memoryPagesInputPerSec(8)

| +-- r-n Gauge32 memoryPagesOutputPerSec(9)

| +-- r-n Gauge32 memoryPagesPerSec(10)

| +-- r-n Gauge32 memoryPoolNonpagedBytes(11)

| +-- r-n Gauge32 memoryPoolPagedBytes(12)

| +-- r-n Gauge32 memoryPoolPagedResidentBytes(13)

| +-- r-n Gauge32 memorySystemCacheResidentBytes(14)

| +-- r-n Gauge32 memorySystemCodeResidentBytes(15)

| +-- r-n Gauge32 memorySystemCodeTotalBytes(16)

| +-- r-n Gauge32 memorySystemDriverResidentBytes(17)

| +-- r-n Gauge32 memorySystemDriverTotalBytes(18)

| +-- r-n Gauge32 memoryCommittedKBytes(19)

| +-- r-n Gauge32 memoryCacheKBytes(20)

| +-- r-n Gauge32 memoryCacheKBytesPeak(21)

| +-- r-n Gauge32 memoryPoolNonpagedKBytes(22)

| +-- r-n Gauge32 memoryPoolPagedKBytes(23)

| +-- r-n Gauge32 memoryPoolPagedResidentKBytes(24)

| +-- r-n Gauge32 memorySystemCacheResidentKBytes(25)

| +-- r-n Gauge32 memorySystemCodeResidentKBytes(26)

| +-- r-n Gauge32 memorySystemCodeTotalKBytes(27)

| +-- r-n Gauge32 memorySystemDriverResidentKBytes(28)

| +-- r-n Gauge32 memorySystemDriverTotalKBytes(29)

| +-- r-n Gauge32 memoryCommittedMBytes(30)

| +-- r-n Gauge32 memoryCacheMBytes(31)

| +-- r-n Gauge32 memoryCacheMBytesPeak(32)

| +-- r-n Gauge32 memoryPoolNonpagedMBytes(33)

| +-- r-n Gauge32 memoryPoolPagedMBytes(34)

| +-- r-n Gauge32 memoryPoolPagedResidentMBytes(35)

| +-- r-n Gauge32 memorySystemCacheResidentMBytes(36)

| +-- r-n Gauge32 memorySystemCodeResidentMBytes(37)

| +-- r-n Gauge32 memorySystemCodeTotalMBytes(38)

| +-- r-n Gauge32 memorySystemDriverResidentMBytes(39)

| +-- r-n Gauge32 memorySystemDriverTotalMBytes(40)

+--networkInterfaceTable(3)

| |

| +--networkInterfaceEntry(1) [netInstance]

| |

| +-- r-n InstanceName netInstance(1)

| +-- r-n Gauge32 netBytesReceivedPerSec(2)

| +-- r-n Gauge32 netBytesSentPerSec(3)

| +-- r-n Gauge32 netBytesTotalPerSec(4)

| +-- r-n Gauge32 netCurrentBandwidth(5)

| +-- r-n Gauge32 netOutputQueueLength(6)

| +-- r-n Gauge32 netPacketsOutboundDiscarded(7)

| +-- r-n Gauge32 netPacketsOutboundErrors(8)

| +-- r-n Gauge32 netPacketsReceivedDiscarded(9)

| +-- r-n Gauge32 netPacketsReceivedErrors(10)

| +-- r-n Gauge32 netPacketsReceivedUnknown(11)

| +-- r-n Gauge32 netPacketsReceivedPerSec(12)

| +-- r-n Gauge32 netPacketsSentPerSec(13)

| +-- r-n Gauge32 netPacketsPerSec(14)

+--objects(4)

| |

| +-- r-n Gauge32 objectsProcesses(1)

| +-- r-n Gauge32 objectsThreads(2)

+--processorTable(5)

| |

| +--processorEntry(1) [cpuInstance]

| |

| +-- r-n InstanceName cpuInstance(1)

| +-- r-n Gauge32 cpuPercentDPCTime(2)

| +-- r-n Gauge32 cpuPercentInterruptTime(3)

| +-- r-n Gauge32 cpuPercentPrivilegedTime(4)

| +-- r-n Gauge32 cpuPercentProcessorTime(5)

| +-- r-n Gauge32 cpuPercentUserTime(6)

| +-- r-n Gauge32 cpuAPCBypassesPerSec(7)

| +-- r-n Gauge32 cpuDPCBypassesPerSec(8)

| +-- r-n Gauge32 cpuDPCRate(9)

| +-- r-n Gauge32 cpuDPCsQueuedPerSec(10)

| +-- r-n Gauge32 cpuInterruptsPerSec(11)

+--system(6)

+-- r-n Gauge32 systemSystemUpTime(1)

MIB v1

INFORMANT-STD DEFINITIONS ::= BEGIN

IMPORTS
    OBJECT-TYPE
        FROM RFC-1212
    Gauge
        FROM RFC1155-SMI
    InstanceName, informant
        FROM WTCS;

standard OBJECT IDENTIFIER
    ::= { informant 1 }

-- standard MODULE-IDENTITY
--     LAST-UPDATED "200807112359Z"
--     ORGANIZATION 
--         "Informant Systems, Inc."
--     CONTACT-INFO 
--         "Garth Williams
--          11135-23A Ave
--          Edmonton, AB  T6J4W5  Canada
--          Tel: +1 780 434 4113
--          E-mail: garth.williams@wtcs.org"
--     DESCRIPTION 
--         "The MIB module for SNMP Informant Standard
--          performance counter entries."
--     REVISION    "200807112359Z"
--     DESCRIPTION 
--         "Multiplied lDiskAvgDiskSecPerRead,
--          lDiskAvgDiskSecPerTransfer,
--          lDiskAvgDiskSecPerWrite by 1000000 and
--          lDiskAvgDiskQueueLength,
--          lDiskAvgDiskReadQueueLength,
--          lDiskAvgDiskWriteQueueLength by 1000 since these
--          values are commonly fractional (less than 1)."
--     REVISION    "200803212308Z"
--     DESCRIPTION 
--         "Added memory OIDs in kilobytes and megabytes
--          to support 64-bit values in Gauge32."
--     REVISION    "200507191826Z"
--     DESCRIPTION 
--         "Added the systemSystemUpTime OID to provide
--          access how long the computer has been up in
--          seconds."
--     REVISION    "200402290627Z"
--     DESCRIPTION 
--         "Changed the syntax of the datapoints from
--          integer to gauge."
--     REVISION    "200401171602Z"
--     DESCRIPTION 
--         "The initial revision of this MIB module."
--     ::= { informant 1 }


logicalDiskTable OBJECT-TYPE
    SYNTAX      SEQUENCE OF LogicalDiskEntry
    ACCESS      not-accessible
    STATUS      mandatory
    DESCRIPTION 
        "The Logical Disk performance object consists
         of counters that monitor logical partitions of
         hard or fixed disk drives. System Monitor
         identifies logical disks by their drive letter,
         such as 'C.' To monitor Logical Disk object
         counters, you must activate them by typing the
         following at the command prompt: diskperf -yv"
    ::= { standard 1 }

logicalDiskEntry OBJECT-TYPE
    SYNTAX      LogicalDiskEntry
    ACCESS      not-accessible
    STATUS      mandatory
    DESCRIPTION 
        "Performance information for one particular
         instance of 'LogicalDisk' object."
    INDEX       { lDiskInstance }
    ::= { logicalDiskTable 1 }

LogicalDiskEntry ::= SEQUENCE {
    lDiskInstance                   InstanceName,
    lDiskPercentDiskReadTime        Gauge,
    lDiskPercentDiskTime            Gauge,
    lDiskPercentDiskWriteTime       Gauge,
    lDiskPercentFreeSpace           Gauge,
    lDiskPercentIdleTime            Gauge,
    lDiskAvgDiskQueueLength         Gauge,
    lDiskAvgDiskReadQueueLength     Gauge,
    lDiskAvgDiskWriteQueueLength    Gauge,
    lDiskAvgDiskSecPerRead          Gauge,
    lDiskAvgDiskSecPerTransfer      Gauge,
    lDiskAvgDiskSecPerWrite         Gauge,
    lDiskCurrentDiskQueueLength     Gauge,
    lDiskDiskBytesPerSec            Gauge,
    lDiskDiskReadBytesPerSec        Gauge,
    lDiskDiskReadsPerSec            Gauge,
    lDiskDiskTransfersPerSec        Gauge,
    lDiskDiskWriteBytesPerSec       Gauge,
    lDiskDiskWritesPerSec           Gauge,
    lDiskFreeMegabytes              Gauge,
    lDiskSplitIOPerSec              Gauge
}

lDiskInstance OBJECT-TYPE
    SYNTAX      InstanceName
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Instance name."
    ::= { logicalDiskEntry 1 }

lDiskPercentDiskReadTime OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "% Disk Read Time is the percentage of elapsed
         time that the selected disk drive is busy
         servicing read requests."
    ::= { logicalDiskEntry 2 }

lDiskPercentDiskTime OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "% Disk Time is the percentage of elapsed time
         that the selected disk drive is busy servicing
         read or write requests."
    ::= { logicalDiskEntry 3 }

lDiskPercentDiskWriteTime OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "% Disk Write Time is the percentage of elapsed
         time that the selected disk drive is busy
         servicing write requests."
    ::= { logicalDiskEntry 4 }

lDiskPercentFreeSpace OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "% Free Space is the ratio of the free space
         available on the logical disk unit to the total
         usable space provided by the selected logical
         disk drive."
    ::= { logicalDiskEntry 5 }

lDiskPercentIdleTime OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "% Idle Time reports the percentage of time
         during the sample interval that the disk was
         idle."
    ::= { logicalDiskEntry 6 }

lDiskAvgDiskQueueLength OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Avg. Disk Queue Length is the average number
         of both read and write requests that were
         queued for the selected disk during the sample
         interval.
         
         Multiplied by 1000 to provide a useful gauge
         value since it is commonly a fractional value."
    ::= { logicalDiskEntry 7 }

lDiskAvgDiskReadQueueLength OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Avg. Disk Read Queue Length is the average
         number of read requests that were queued for
         the selected disk during the sample interval.
         
         Multiplied by 1000 to provide a useful gauge
         value since it is commonly a fractional value."
    ::= { logicalDiskEntry 8 }

lDiskAvgDiskWriteQueueLength OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Avg. Disk Write Queue Length is the average
         number of write requests that were queued for
         the selected disk during the sample interval.
         
         Multiplied by 1000 to provide a useful gauge
         value since it is commonly a fractional value."
    ::= { logicalDiskEntry 9 }

lDiskAvgDiskSecPerRead OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Avg. Disk sec/Read is the average time, in
         seconds, of a read of data from the disk.
         
         Multiplied by 1000000 to provide a useful gauge
         value since it is commonly a fractional value."
    ::= { logicalDiskEntry 10 }

lDiskAvgDiskSecPerTransfer OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Avg. Disk sec/Transfer is the time, in
         seconds, of the average disk transfer.
         
         Multiplied by 1000000 to provide a useful gauge
         value since it is commonly a fractional value."
    ::= { logicalDiskEntry 11 }

lDiskAvgDiskSecPerWrite OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Avg. Disk sec/Write is the average time, in
         seconds, of a write of data to the disk.
         
         Multiplied by 1000000 to provide a useful gauge
         value since it is commonly a fractional value."
    ::= { logicalDiskEntry 12 }

lDiskCurrentDiskQueueLength OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Current Disk Queue Length is the number of
         requests outstanding on the disk at the time
         the performance data is collected.	It includes
         requests in service at the time of the
         snapshot.  This is an instantaneous length, not
         an average over the time interval. 
         Multi-spindle disk devices can have multiple
         requests active at one time, but other
         concurrent requests are awaiting service.  This
         counter might reflect a transitory high or low
         queue length, but if there is a sustained load
         on the disk drive, it is likely that this will
         be consistently high.  Requests are
         experiencing delays proportional to the length
         of this queue minus the number of spindles on
         the disks.	This difference should average less
         than 2 for good performance."
    ::= { logicalDiskEntry 13 }

lDiskDiskBytesPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Disk Bytes/sec is the rate bytes are
         transferred to or from the disk during write or
         read operations."
    ::= { logicalDiskEntry 14 }

lDiskDiskReadBytesPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Disk Read Bytes/sec is the rate bytes are
         transferred from the disk during read
         operations."
    ::= { logicalDiskEntry 15 }

lDiskDiskReadsPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Disk Reads/sec is the rate of read operations
         on the disk."
    ::= { logicalDiskEntry 16 }

lDiskDiskTransfersPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Disk Transfers/sec is the rate of read and
         write operations on the disk."
    ::= { logicalDiskEntry 17 }

lDiskDiskWriteBytesPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Disk Write Bytes is rate bytes are transferred
         to the disk during write operations."
    ::= { logicalDiskEntry 18 }

lDiskDiskWritesPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Disk Writes/sec is the rate of write
         operations on the disk."
    ::= { logicalDiskEntry 19 }

lDiskFreeMegabytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Free Megabytes displays the unallocated space
         on the disk drive in megabytes. One megabyte =
         1,048,576 bytes."
    ::= { logicalDiskEntry 20 }

lDiskSplitIOPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Split IO/Sec reports the rate that I/Os to the
         disk were split into multiple I/Os.  A split
         I/O may result from requesting data in a size
         that is too large to fit into a single I/O or
         that the disk is fragmented."
    ::= { logicalDiskEntry 21 }

memory OBJECT IDENTIFIER
    ::= { standard 2 }

memoryAvailableBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Available Bytes is the amount of physical
         memory available to processes running on the
         computer, in bytes.  It is calculated by
         summing 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. "
    ::= { memory 1 }

memoryAvailableKBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Available KBytes is the amount of physical
         memory available to processes running on the
         computer, in Kilobytes (Bytes / 1,024).  It is
         calculated by summing 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. "
    ::= { memory 2 }

memoryAvailableMBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Available MBytes is the amount of physical
         memory available to processes running on the
         computer, in Megabytes (Bytes / 1,048,576).  It
         is calculated by summing 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. "
    ::= { memory 3 }

memoryCommittedBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Committed Bytes is the amount of committed
         virtual memory, in bytes.  (Committed memory is
         physical memory for which space has been
         reserved on the disk paging file in case it
         needs to be written back to disk). This counter
         displays the last observed value only; it is
         not an average. "
    ::= { memory 4 }

memoryCacheBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Cache Bytes is the sum of the System Cache
         Resident Bytes, System Driver Resident Bytes,
         System Code Resident Bytes, and Pool Paged
         Resident Bytes counters.  This counter displays
         the last observed value only; it is not an
         average. "
    ::= { memory 5 }

memoryCacheBytesPeak OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Cache Bytes Peak is the maximum value of Cache
         Bytes since the system was last restarted. 
         This value might be larger than the current
         size of the cache.	Cache Bytes is the sum of
         the System Cache Resident Bytes, System Driver
         Resident Bytes, System Code Resident Bytes, and
         Pool Paged Resident Bytes counters.  This
         counter displays the last observed value only;
         it is not an average. "
    ::= { memory 6 }

memoryPageFaultsPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Page Faults/sec is the overall rate faulted
         pages are handled by the processor.  It is
         measured in numbers of pages faulted per
         second.  A page fault occurs when a process
         requires code or data that is not in its
         working set (its space in physical memory). 
         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
         consequence.  However, hard faults can cause
         significant delays. This counter displays the
         difference between the values observed in the
         last two samples, divided by the duration of
         the sample interval. "
    ::= { memory 7 }

memoryPagesInputPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Pages Input/sec is the number of pages read
         from disk to resolve hard page faults.  (Hard
         page faults occur when a process requires code
         or data that is not in its working set or
         elsewhere in physical memory, and must be
         retrieved from disk). This counter was designed
         as a primary indicator of the kinds of faults
         that cause system-wide delays.  It includes
         pages retrieved to satisfy faults in the file
         system cache (usually requested by
         applications) and in non-cached mapped memory
         files.  This counter counts numbers of pages,
         and can be compared to other counts of pages,
         such as Memory: Page Faults/sec, without
         conversion.  This counter displays the
         difference between the values observed in the
         last two samples, divided by the duration of
         the sample interval. "
    ::= { memory 8 }

memoryPagesOutputPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Pages Output/sec is the number of pages
         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 NT writes more pages back to
         disk to free up space when physical memory is
         in short supply.  This counter counts numbers
         of pages, and can be compared to other counts
         of pages, without conversion.  This counter
         displays the difference between the values
         observed in the last two samples, divided by
         the duration of the sample interval. "
    ::= { memory 9 }

memoryPagesPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Pages/sec is the number of pages read from or
         written to disk to resolve hard page faults. 
         (Hard page faults occur when a process requires
         code or data that is not in its working set or
         elsewhere in physical memory, and must be
         retrieved from disk). This counter was designed
         as 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.  This counter displays the
         difference between the values observed in the
         last two samples, divided by the duration of
         the sample interval. "
    ::= { memory 10 }

memoryPoolNonpagedBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Pool Nonpaged Bytes is the number of bytes in
         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.  "
    ::= { memory 11 }

memoryPoolPagedBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Pool Paged Bytes is the number of bytes in 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.  "
    ::= { memory 12 }

memoryPoolPagedResidentBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Pool Paged Resident Bytes is the current size
         of paged pool in bytes.  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. "
    ::= { memory 13 }

memorySystemCacheResidentBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Cache Resident Bytes is the number of
         bytes from the file system cache that are
         resident in physical memory.  This value
         includes only current physical pages and does
         not include any virtual memory pages not
         currently resident.  As such 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.  This counter displays the last
         observed value only; it is not an average. "
    ::= { memory 14 }

memorySystemCodeResidentBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Code Resident Bytes is the number of
         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 and cannot be written to disk. 
         This counter displays the last observed value
         only; it is not an average.  "
    ::= { memory 15 }

memorySystemCodeTotalBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Code Total Bytes is the number of 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 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. "
    ::= { memory 16 }

memorySystemDriverResidentBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Driver Resident Bytes is the number of
         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 System
         Driver Resident Bytes nor System Driver Total
         Bytes includes memory that cannot be written to
         disk."
    ::= { memory 17 }

memorySystemDriverTotalBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Driver Total Bytes is the number of
         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
         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.  "
    ::= { memory 18 }

memoryCommittedKBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Committed KiloBytes is the amount of committed
         virtual memory, in kilobytes. 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."
    ::= { memory 19 }

memoryCacheKBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Cache KiloBytes is the sum of the
         Memory\\System Cache Resident KiloBytes,
         Memory\\System Driver Resident KiloBytes,
         Memory\\System Code Resident KiloBytes, and
         Memory\\Pool Paged Resident KiloBytes counters.
          This counter displays the last observed value
         only; it is not an average. "
    ::= { memory 20 }

memoryCacheKBytesPeak OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Cache KiloBytes Peak is the maximum number of
         kilobytes 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. "
    ::= { memory 21 }

memoryPoolNonpagedKBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Pool Nonpaged KiloBytes is the size, in
         kilobytes, 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 KiloBytes is calculated
         differently than Process\\Pool Nonpaged
         KiloBytes, so it might not equal Process\\Pool
         Nonpaged KiloBytes\\_Total.  This counter
         displays the last observed value only; it is
         not an average."
    ::= { memory 22 }

memoryPoolPagedKBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Pool Paged KiloBytes is the size, in
         kilobytes, 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 KiloBytes is calculated differently than
         Process\\Pool Paged KiloBytes, so it might not
         equal Process\\Pool Paged KiloBytes\\_Total.
         This counter displays the last observed value
         only; it is not an average."
    ::= { memory 23 }

memoryPoolPagedResidentKBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Pool Paged Resident KiloBytes is the current
         size, in kilobytes, 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."
    ::= { memory 24 }

memorySystemCacheResidentKBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Cache Resident KiloBytes is the size,
         in kilobytes, 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 KiloBytes 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. "
    ::= { memory 25 }

memorySystemCodeResidentKBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Code Resident KiloBytes is the size, in
         kilobytes 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
         KiloBytes, which also includes operating system
         code on disk. Memory\\System Code Resident
         KiloBytes (and Memory\\System Code Total
         KiloBytes) 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."
    ::= { memory 26 }

memorySystemCodeTotalKBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Code Total KiloBytes is the size, in
         kilobytes, 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 kilobytes 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."
    ::= { memory 27 }

memorySystemDriverResidentKBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Driver Resident KiloBytes is the size,
         in kilobytes, 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 KiloBytes, which also includes driver
         memory that has been written to disk. Neither
         Memory\\System Driver Resident KiloBytes nor
         Memory\\System Driver Total KiloBytes includes
         memory that cannot be written to disk."
    ::= { memory 28 }

memorySystemDriverTotalKBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Driver Total KiloBytes is the size, in
         kilobytes, 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 KiloBytes) and
         code and data paged to disk. It is a component
         of Memory\\System Code Total KiloBytes. This
         counter displays the last observed value only;
         it is not an average.  "
    ::= { memory 29 }

memoryCommittedMBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Committed MegaBytes is the amount of committed
         virtual memory, in megabytes. 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."
    ::= { memory 30 }

memoryCacheMBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Cache MegaBytes is the sum of the
         Memory\\System Cache Resident MegaBytes,
         Memory\\System Driver Resident MegaBytes,
         Memory\\System Code Resident MegaBytes, and
         Memory\\Pool Paged Resident MegaBytes counters.
          This counter displays the last observed value
         only; it is not an average. "
    ::= { memory 31 }

memoryCacheMBytesPeak OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Cache MegaBytes Peak is the maximum number of
         megabytes 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. "
    ::= { memory 32 }

memoryPoolNonpagedMBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Pool Nonpaged MegaBytes is the size, in
         megabytes, 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 MegaBytes is calculated
         differently than Process\\Pool Nonpaged
         MegaBytes, so it might not equal Process\\Pool
         Nonpaged MegaBytes\\_Total.  This counter
         displays the last observed value only; it is
         not an average."
    ::= { memory 33 }

memoryPoolPagedMBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Pool Paged MegaBytes is the size, in
         megabytes, 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 MegaBytes is calculated differently than
         Process\\Pool Paged MegaBytes, so it might not
         equal Process\\Pool Paged MegaBytes\\_Total.
         This counter displays the last observed value
         only; it is not an average."
    ::= { memory 34 }

memoryPoolPagedResidentMBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Pool Paged Resident MegaBytes is the current
         size, in megabytes, 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."
    ::= { memory 35 }

memorySystemCacheResidentMBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Cache Resident MegaBytes is the size,
         in megabytes, 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 MegaBytes 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. "
    ::= { memory 36 }

memorySystemCodeResidentMBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Code Resident MegaBytes is the size, in
         megabytes 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
         MegaBytes, which also includes operating system
         code on disk. Memory\\System Code Resident
         MegaBytes (and Memory\\System Code Total
         MegaBytes) 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."
    ::= { memory 37 }

memorySystemCodeTotalMBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Code Total MegaBytes is the size, in
         megabytes, 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 megabytes 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."
    ::= { memory 38 }

memorySystemDriverResidentMBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Driver Resident MegaBytes is the size,
         in megabytes, 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 MegaBytes, which also includes driver
         memory that has been written to disk. Neither
         Memory\\System Driver Resident MegaBytes nor
         Memory\\System Driver Total MegaBytes includes
         memory that cannot be written to disk."
    ::= { memory 39 }

memorySystemDriverTotalMBytes OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Driver Total MegaBytes is the size, in
         megabytes, 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 MegaBytes) and
         code and data paged to disk. It is a component
         of Memory\\System Code Total MegaBytes. This
         counter displays the last observed value only;
         it is not an average.  "
    ::= { memory 40 }

networkInterfaceTable OBJECT-TYPE
    SYNTAX      SEQUENCE OF NetworkInterfaceEntry
    ACCESS      not-accessible
    STATUS      mandatory
    DESCRIPTION 
        "The Network Interface performance object
         consists of counters that measure the rates at
         which bytes and packets are sent and received
         over a TCP/IP connection. It includes counters
         that monitor connection errors. The Network
         Interface counters display data about the
         network adapters on the server computer. The
         first instance of the Network Interface object
         (Instance 1) that you see in System Monitor
         represents the loopback. The loopback is a
         local path through the protocol driver and the
         network adapter. All other instances represent
         installed network adapters."
    ::= { standard 3 }

networkInterfaceEntry OBJECT-TYPE
    SYNTAX      NetworkInterfaceEntry
    ACCESS      not-accessible
    STATUS      mandatory
    DESCRIPTION 
        "Performance information for one particular
         instance of 'Network Interface' object."
    INDEX       { netInstance }
    ::= { networkInterfaceTable 1 }

NetworkInterfaceEntry ::= SEQUENCE {
    netInstance                     InstanceName,
    netBytesReceivedPerSec          Gauge,
    netBytesSentPerSec              Gauge,
    netBytesTotalPerSec             Gauge,
    netCurrentBandwidth             Gauge,
    netOutputQueueLength            Gauge,
    netPacketsOutboundDiscarded     Gauge,
    netPacketsOutboundErrors        Gauge,
    netPacketsReceivedDiscarded     Gauge,
    netPacketsReceivedErrors        Gauge,
    netPacketsReceivedUnknown       Gauge,
    netPacketsReceivedPerSec        Gauge,
    netPacketsSentPerSec            Gauge,
    netPacketsPerSec                Gauge
}

netInstance OBJECT-TYPE
    SYNTAX      InstanceName
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Instance name."
    ::= { networkInterfaceEntry 1 }

netBytesReceivedPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Bytes Received/sec is the rate at which bytes
         are received on the interface, including
         framing characters."
    ::= { networkInterfaceEntry 2 }

netBytesSentPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Bytes Sent/sec is the rate at which bytes are
         sent on the interface, including framing
         characters."
    ::= { networkInterfaceEntry 3 }

netBytesTotalPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Bytes Total/sec is the rate at which bytes are
         sent and received on the interface, including
         framing characters."
    ::= { networkInterfaceEntry 4 }

netCurrentBandwidth OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Current Bandwidth is an estimate of the
         interface's current bandwidth in bits per
         second (BPS).  For interfaces that do not vary
         in bandwidth or for those where no accurate
         estimation can be made, this value is the
         nominal bandwidth."
    ::= { networkInterfaceEntry 5 }

netOutputQueueLength OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Output Queue Length is the length of the
         output packet queue (in packets).  If this is
         longer than 2, delays are being experienced and
         the bottleneck should be found and eliminated
         if possible.  Since the requests are queued by
         NDIS in this implementation, this will always
         be 0."
    ::= { networkInterfaceEntry 6 }

netPacketsOutboundDiscarded OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Packets Outbound Discarded is the number of
         outbound packets that were chosen to be
         discarded even though no errors had been
         detected to prevent their being transmitted. 
         One possible reason for discarding such a
         packet could be to free up buffer space."
    ::= { networkInterfaceEntry 7 }

netPacketsOutboundErrors OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Packets Outbound Errors is the number of
         outbound packets that could not be transmitted
         because of errors."
    ::= { networkInterfaceEntry 8 }

netPacketsReceivedDiscarded OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Packets Received Discarded is the number of
         inbound packets that were chosen to be
         discarded even though no errors had been
         detected to prevent their being deliverable to
         a higher-layer protocol.  One possible reason
         for discarding such a packet could be to free
         up buffer space."
    ::= { networkInterfaceEntry 9 }

netPacketsReceivedErrors OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Packets Received Errors is the number of
         inbound packets that contained errors
         preventing them from being deliverable to a
         higher-layer protocol."
    ::= { networkInterfaceEntry 10 }

netPacketsReceivedUnknown OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Packets Received Unknown is the number of
         packets received via the interface that were
         discarded because of an unknown or unsupported
         protocol."
    ::= { networkInterfaceEntry 11 }

netPacketsReceivedPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Packets Received/sec is the rate at which
         packets are received on the network interface."
    ::= { networkInterfaceEntry 12 }

netPacketsSentPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Packets Sent/sec is the rate at which packets
         are sent on the network interface."
    ::= { networkInterfaceEntry 13 }

netPacketsPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Packets/sec is the rate at which packets are
         sent and received on the network interface."
    ::= { networkInterfaceEntry 14 }

objects OBJECT IDENTIFIER
    ::= { standard 4 }

objectsProcesses OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Processes is the number of processes in the
         computer at the time of data collection. 
         Notice that this is an instantaneous count, not
         an average over the time interval.	Each
         process represents the running of a program."
    ::= { objects 1 }

objectsThreads OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Threads is the number of threads in the
         computer at the time of data collection. 
         Notice that this is an instantaneous count, not
         an average over the time interval.	A thread is
         the basic executable entity that can execute
         instructions in a processor."
    ::= { objects 2 }

processorTable OBJECT-TYPE
    SYNTAX      SEQUENCE OF ProcessorEntry
    ACCESS      not-accessible
    STATUS      mandatory
    DESCRIPTION 
        "The Processor performance object consists of
         counters that measure aspects of processor
         activity. The processor is the part of the
         computer that performs arithmetic and logical
         computations, initiates operations on
         peripherals, and runs the threads of processes.
         A computer can have multiple processors. The
         processor object represents each processor as
         an instance of the object."
    ::= { standard 5 }

processorEntry OBJECT-TYPE
    SYNTAX      ProcessorEntry
    ACCESS      not-accessible
    STATUS      mandatory
    DESCRIPTION 
        "Performance information for one particular
         instance of 'Processor' object."
    INDEX       { cpuInstance }
    ::= { processorTable 1 }

ProcessorEntry ::= SEQUENCE {
    cpuInstance                 InstanceName,
    cpuPercentDPCTime           Gauge,
    cpuPercentInterruptTime     Gauge,
    cpuPercentPrivilegedTime    Gauge,
    cpuPercentProcessorTime     Gauge,
    cpuPercentUserTime          Gauge,
    cpuAPCBypassesPerSec        Gauge,
    cpuDPCBypassesPerSec        Gauge,
    cpuDPCRate                  Gauge,
    cpuDPCsQueuedPerSec         Gauge,
    cpuInterruptsPerSec         Gauge
}

cpuInstance OBJECT-TYPE
    SYNTAX      InstanceName
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Instance name."
    ::= { processorEntry 1 }

cpuPercentDPCTime OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "% DPC Time is the percentage of time that the
         processor spent receiving and servicing
         deferred procedure calls (DPCs) during the
         sample interval.  (DPCs are interrupts that run
         at a lower priority than standard interrupts).
         % DPC Time is a component of % Privileged Time
         because DPCs are executed in privileged mode. 
         They are counted separately and are not a
         component of the interrupt counters.  This
         counter displays the average busy time as a
         percentage of the sample time. "
    ::= { processorEntry 2 }

cpuPercentInterruptTime OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "% Interrupt Time is the percentage of time the
         processor spent receiving and servicing
         hardware interrupts during the sample interval.
          This value is an indirect indicator of the
         activity of devices that generate interrupts,
         such as the system clock, the mouse, disk
         drivers, data communication lines, network
         interface cards and other peripheral devices.
         These devices normally interrupt the processor
         when they have completed a task or require
         attention.	Normal thread execution is
         suspended during interrupts.  Most system
         clocks interrupt the processor every 10
         milliseconds, creating a background of
         interrupt activity.  This counter displays the
         average busy time as a percentage of the sample
         time. "
    ::= { processorEntry 3 }

cpuPercentPrivilegedTime OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "% Privileged Time is the percentage of
         non-idle processor time spent in privileged
         mode.  (Privileged mode is a processing mode
         designed for operating system components and
         hardware-manipulating drivers.  It allows
         direct access to hardware and all memory.  The
         alternative, user mode, is a restricted
         processing mode designed for applications,
         environment subsystems, and integral
         subsystems.  The operating system switches
         application threads to privileged mode to
         access operating system services). % Privileged
         Time includes time servicing interrupts and
         DPCs.  A high rate of privileged time might be
         attributable to a large number of interrupts
         generated by a failing device.  This counter
         displays the average busy time as a percentage
         of the sample time. "
    ::= { processorEntry 4 }

cpuPercentProcessorTime OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "% Processor Time is the percentage of time
         that the processor is executing a non-Idle
         thread.  This counter was designed as a primary
         indicator of processor activity.  It is
         calculated by measuring the time that the
         processor spends executing the thread of the
         Idle process in each sample interval, and
         subtracting that value from 100%.  (Each
         processor has an Idle thread which consumes
         cycles when no other threads are ready to run).
         It can be viewed as the percentage of the
         sample interval spent doing useful work.  This
         counter displays the average percentage of busy
         time observed during the sample interval.  It
         is calculated by monitoring the time the
         service was inactive, and then subtracting that
         value from 100%."
    ::= { processorEntry 5 }

cpuPercentUserTime OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "% User Time is the percentage of non-idle
         processor time spent in user mode.	(User mode
         is a restricted processing mode designed for
         applications, environment subsystems, and
         integral subsystems.  The alternative,
         privileged mode, is designed for operating
         system components and allows direct access to
         hardware and all memory.  The operating system
         switches application threads to privileged mode
         to access operating system services). This
         counter displays the average busy time as a
         percentage of the sample time. "
    ::= { processorEntry 6 }

cpuAPCBypassesPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "APC Bypasses/sec is the rate at which Kernel
         APC interrupts were avoided.  APC Bypasses/sec
         is the rate at which kernel APC interrupts were
         short-circuited.  This counter displays the
         difference between the values observed in the
         last two samples, divided by the duration of
         the sample interval."
    ::= { processorEntry 7 }

cpuDPCBypassesPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "DPC Bypasses/sec is the rate at which deferred
         procedure calls (DPCs) on all processors were
         avoided.  (DPCs are interrupts that run at a
         lower priority than standard interrupts). This
         counter displays the difference between the
         values observed in the last two samples,
         divided by the duration of the sample
         interval."
    ::= { processorEntry 8 }

cpuDPCRate OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "DPC Rate is the rate at which deferred
         procedure calls (DPCs) are added to the
         processor's DPC queue between the timer ticks
         of the processor clock.  (DPCs are interrupts
         that run at a lower priority than standard
         interrupts.  Each processor has its own DPC
         queue). This counter measures the rate at which
         DPCs are added to the queue, not the number of
         DPCs in the queue.	This counter displays the
         last observed value only; it is not an average."
    ::= { processorEntry 9 }

cpuDPCsQueuedPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "DPCs Queued/sec is the overall rate at which
         deferred procedure calls (DPCs) are added to
         the processor's DPC queue.	(DPCs are
         interrupts that run at a lower priority than
         standard interrupts.  Each processor has its
         own DPC queue). This counter measures the rate
         at which DPCs are added to the queue, not the
         number of DPCs in the queue.  This counter
         displays the difference between the values
         observed in the last two samples, divided by
         the duration of the sample interval. "
    ::= { processorEntry 10 }

cpuInterruptsPerSec OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "Interrupts/sec is the average number of
         hardware interrupts the processor is receiving
         and servicing in each second. It does not
         include DPCs, which are counted separately.
         This value is an indirect indicator of the
         activity of devices that generate interrupts,
         such as the system clock, the mouse, disk
         drivers, data communication lines, network
         interface cards and other peripheral devices.
         These devices normally interrupt the processor
         when they have completed a task or require
         attention. Normal thread execution is suspended
         during interrupts. Most system clocks interrupt
         the processor every 10 milliseconds, creating a
         background of interrupt activity. This counter
         displays the difference between the values
         observed in the last two samples, divided by
         the duration of the sample interval. "
    ::= { processorEntry 11 }

system OBJECT IDENTIFIER
    ::= { standard 6 }

systemSystemUpTime OBJECT-TYPE
    SYNTAX      Gauge
    ACCESS      read-only
    STATUS      mandatory
    DESCRIPTION 
        "System Up Time is the elapsed time (in
         seconds) that the computer has been running
         since it was last started.	This counter
         displays the difference between the start time
         and the current time. "
    ::= { system 1 }

END -- end of module INFORMANT-STD.

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

1001

1002

1003

1004

1005

1006

1007

1008

1009

1010

1011

1012

1013

1014

1015

1016

1017

1018

1019

1020

1021

1022

1023

1024

1025

1026

1027

1028

1029

1030

1031

1032

1033

1034

1035

1036

1037

1038

1039

1040

1041

1042

1043

1044

1045

1046

1047

1048

1049

1050

1051

1052

1053

1054

1055

1056

1057

1058

1059

1060

1061

1062

1063

1064

1065

1066

1067

1068

1069

1070

1071

1072

1073

1074

1075

1076

1077

1078

1079

1080

1081

1082

1083

1084

1085

1086

1087

1088

1089

1090

1091

1092

1093

1094

1095

1096

1097

1098

1099

1100

1101

1102

1103

1104

1105

1106

1107

1108

1109

1110

1111

1112

1113

1114

1115

1116

1117

1118

1119

1120

1121

1122

1123

1124

1125

1126

1127

1128

1129

1130

1131

1132

1133

1134

1135

1136

1137

1138

1139

1140

1141

1142

1143

1144

1145

1146

1147

1148

1149

1150

1151

1152

1153

1154

1155

1156

1157

1158

1159

1160

1161

1162

1163

1164

1165

1166

1167

1168

1169

1170

1171

1172

1173

1174

1175

1176

1177

1178

1179

1180

1181

1182

1183

1184

1185

1186

1187

1188

1189

1190

1191

1192

1193

1194

1195

1196

1197

1198

1199

1200

1201

1202

1203

1204

1205

1206

1207

1208

1209

1210

1211

1212

1213

1214

1215

1216

1217

1218

1219

1220

1221

1222

1223

1224

1225

1226

1227

1228

1229

1230

1231

1232

1233

1234

1235

1236

1237

1238

1239

1240

1241

1242

1243

1244

1245

1246

1247

1248

1249

1250

1251

1252

1253

1254

1255

1256

1257

1258

1259

1260

1261

1262

1263

1264

1265

1266

1267

1268

1269

1270

1271

1272

1273

1274

1275

1276

1277

1278

1279

1280

1281

1282

1283

1284

1285

1286

1287

1288

1289

1290

1291

1292

1293

1294

1295

1296

1297

1298

1299

1300

1301

1302

1303

1304

1305

1306

1307

1308

1309

1310

1311

1312

1313

1314

1315

1316

1317

1318

1319

1320

1321

1322

1323

1324

1325

1326

1327

1328

1329

1330

1331

1332

1333

1334

1335

1336

1337

1338

1339

1340

1341

1342

1343

1344

1345

1346

1347

1348

1349

1350

1351

1352

1353

1354

1355

1356

1357

1358

1359

1360

1361

1362

1363

1364

1365

1366

1367

1368

1369

1370

1371

1372

1373

1374

1375

1376

1377

1378

1379

1380

1381

1382

1383

1384

1385

1386

1387

1388

1389

1390

1391

1392

1393

1394

1395

1396

1397

1398

1399

1400

1401

1402

1403

1404

1405

1406

1407

1408

1409

1410

1411

1412

1413

1414

1415

1416

1417

1418

1419

1420

1421

1422

1423

1424

1425

1426

1427

1428

1429

1430

1431

1432

1433

1434

1435

1436

1437

1438

1439

1440

1441

1442

1443

1444

1445

1446

1447

1448

1449

1450

1451

1452

1453

1454

1455

1456

1457

1458

1459

1460

1461

1462

1463

1464

1465

1466

1467

1468

1469

1470

1471

1472

1473

1474

1475

1476

1477

1478

1479

1480

1481

1482

1483

1484

1485

1486

1487

1488

1489

1490

1491

1492

1493

1494

1495

1496

1497

1498

1499

1500

1501

1502

1503

1504

1505

1506

1507

1508

1509

1510

1511

1512

1513

1514

1515

1516

1517

1518

1519

1520

1521

1522

1523

1524

1525

1526

1527

1528

1529

1530

1531

1532

1533

1534

1535

1536

1537

1538

1539

1540

1541

1542

1543

1544

1545

1546

1547

1548

1549

1550

1551

INFORMANT-STD DEFINITIONS ::= BEGIN

IMPORTS

OBJECT-TYPE

FROM RFC-1212

Gauge

FROM RFC1155-SMI

InstanceName, informant

FROM WTCS;

standard OBJECT IDENTIFIER

::= { informant 1 }

-- standard MODULE-IDENTITY

-- LAST-UPDATED "200807112359Z"

-- ORGANIZATION

-- "Informant Systems, Inc."

-- CONTACT-INFO

-- "Garth Williams

-- 11135-23A Ave

-- Edmonton, AB T6J4W5 Canada

-- Tel: +1 780 434 4113

-- E-mail: garth.williams@wtcs.org"

-- DESCRIPTION

-- "The MIB module for SNMP Informant Standard

-- performance counter entries."

-- REVISION "200807112359Z"

-- DESCRIPTION

-- "Multiplied lDiskAvgDiskSecPerRead,

-- lDiskAvgDiskSecPerTransfer,

-- lDiskAvgDiskSecPerWrite by 1000000 and

-- lDiskAvgDiskQueueLength,

-- lDiskAvgDiskReadQueueLength,

-- lDiskAvgDiskWriteQueueLength by 1000 since these

-- values are commonly fractional (less than 1)."

-- REVISION "200803212308Z"

-- DESCRIPTION

-- "Added memory OIDs in kilobytes and megabytes

-- to support 64-bit values in Gauge32."

-- REVISION "200507191826Z"

-- DESCRIPTION

-- "Added the systemSystemUpTime OID to provide

-- access how long the computer has been up in

-- seconds."

-- REVISION "200402290627Z"

-- DESCRIPTION

-- "Changed the syntax of the datapoints from

-- integer to gauge."

-- REVISION "200401171602Z"

-- DESCRIPTION

-- "The initial revision of this MIB module."

-- ::= { informant 1 }

logicalDiskTable OBJECT-TYPE

SYNTAX SEQUENCE OF LogicalDiskEntry

ACCESS not-accessible

STATUS mandatory

DESCRIPTION

"The Logical Disk performance object consists

of counters that monitor logical partitions of

hard or fixed disk drives. System Monitor

identifies logical disks by their drive letter,

such as 'C.' To monitor Logical Disk object

counters, you must activate them by typing the

following at the command prompt: diskperf -yv"

::= { standard 1 }

logicalDiskEntry OBJECT-TYPE

SYNTAX LogicalDiskEntry

ACCESS not-accessible

STATUS mandatory

DESCRIPTION

"Performance information for one particular

instance of 'LogicalDisk' object."

INDEX { lDiskInstance }

::= { logicalDiskTable 1 }

LogicalDiskEntry ::= SEQUENCE {

lDiskInstance InstanceName,

lDiskPercentDiskReadTime Gauge,

lDiskPercentDiskTime Gauge,

lDiskPercentDiskWriteTime Gauge,

lDiskPercentFreeSpace Gauge,

lDiskPercentIdleTime Gauge,

lDiskAvgDiskQueueLength Gauge,

lDiskAvgDiskReadQueueLength Gauge,

lDiskAvgDiskWriteQueueLength Gauge,

lDiskAvgDiskSecPerRead Gauge,

lDiskAvgDiskSecPerTransfer Gauge,

lDiskAvgDiskSecPerWrite Gauge,

lDiskCurrentDiskQueueLength Gauge,

lDiskDiskBytesPerSec Gauge,

lDiskDiskReadBytesPerSec Gauge,

lDiskDiskReadsPerSec Gauge,

lDiskDiskTransfersPerSec Gauge,

lDiskDiskWriteBytesPerSec Gauge,

lDiskDiskWritesPerSec Gauge,

lDiskFreeMegabytes Gauge,

lDiskSplitIOPerSec Gauge

}

lDiskInstance OBJECT-TYPE

SYNTAX InstanceName

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Instance name."

::= { logicalDiskEntry 1 }

lDiskPercentDiskReadTime OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"% Disk Read Time is the percentage of elapsed

time that the selected disk drive is busy

servicing read requests."

::= { logicalDiskEntry 2 }

lDiskPercentDiskTime OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"% Disk Time is the percentage of elapsed time

that the selected disk drive is busy servicing

read or write requests."

::= { logicalDiskEntry 3 }

lDiskPercentDiskWriteTime OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"% Disk Write Time is the percentage of elapsed

time that the selected disk drive is busy

servicing write requests."

::= { logicalDiskEntry 4 }

lDiskPercentFreeSpace OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"% Free Space is the ratio of the free space

available on the logical disk unit to the total

usable space provided by the selected logical

disk drive."

::= { logicalDiskEntry 5 }

lDiskPercentIdleTime OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"% Idle Time reports the percentage of time

during the sample interval that the disk was

idle."

::= { logicalDiskEntry 6 }

lDiskAvgDiskQueueLength OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Avg. Disk Queue Length is the average number

of both read and write requests that were

queued for the selected disk during the sample

interval.

Multiplied by 1000 to provide a useful gauge

value since it is commonly a fractional value."

::= { logicalDiskEntry 7 }

lDiskAvgDiskReadQueueLength OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Avg. Disk Read Queue Length is the average

number of read requests that were queued for

the selected disk during the sample interval.

Multiplied by 1000 to provide a useful gauge

value since it is commonly a fractional value."

::= { logicalDiskEntry 8 }

lDiskAvgDiskWriteQueueLength OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Avg. Disk Write Queue Length is the average

number of write requests that were queued for

the selected disk during the sample interval.

Multiplied by 1000 to provide a useful gauge

value since it is commonly a fractional value."

::= { logicalDiskEntry 9 }

lDiskAvgDiskSecPerRead OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Avg. Disk sec/Read is the average time, in

seconds, of a read of data from the disk.

Multiplied by 1000000 to provide a useful gauge

value since it is commonly a fractional value."

::= { logicalDiskEntry 10 }

lDiskAvgDiskSecPerTransfer OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Avg. Disk sec/Transfer is the time, in

seconds, of the average disk transfer.

Multiplied by 1000000 to provide a useful gauge

value since it is commonly a fractional value."

::= { logicalDiskEntry 11 }

lDiskAvgDiskSecPerWrite OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Avg. Disk sec/Write is the average time, in

seconds, of a write of data to the disk.

Multiplied by 1000000 to provide a useful gauge

value since it is commonly a fractional value."

::= { logicalDiskEntry 12 }

lDiskCurrentDiskQueueLength OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Current Disk Queue Length is the number of

requests outstanding on the disk at the time

the performance data is collected. It includes

requests in service at the time of the

snapshot. This is an instantaneous length, not

an average over the time interval.

Multi-spindle disk devices can have multiple

requests active at one time, but other

concurrent requests are awaiting service. This

counter might reflect a transitory high or low

queue length, but if there is a sustained load

on the disk drive, it is likely that this will

be consistently high. Requests are

experiencing delays proportional to the length

of this queue minus the number of spindles on

the disks. This difference should average less

than 2 for good performance."

::= { logicalDiskEntry 13 }

lDiskDiskBytesPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Disk Bytes/sec is the rate bytes are

transferred to or from the disk during write or

read operations."

::= { logicalDiskEntry 14 }

lDiskDiskReadBytesPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Disk Read Bytes/sec is the rate bytes are

transferred from the disk during read

operations."

::= { logicalDiskEntry 15 }

lDiskDiskReadsPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Disk Reads/sec is the rate of read operations

on the disk."

::= { logicalDiskEntry 16 }

lDiskDiskTransfersPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Disk Transfers/sec is the rate of read and

write operations on the disk."

::= { logicalDiskEntry 17 }

lDiskDiskWriteBytesPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Disk Write Bytes is rate bytes are transferred

to the disk during write operations."

::= { logicalDiskEntry 18 }

lDiskDiskWritesPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Disk Writes/sec is the rate of write

operations on the disk."

::= { logicalDiskEntry 19 }

lDiskFreeMegabytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Free Megabytes displays the unallocated space

on the disk drive in megabytes. One megabyte =

1,048,576 bytes."

::= { logicalDiskEntry 20 }

lDiskSplitIOPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Split IO/Sec reports the rate that I/Os to the

disk were split into multiple I/Os. A split

I/O may result from requesting data in a size

that is too large to fit into a single I/O or

that the disk is fragmented."

::= { logicalDiskEntry 21 }

memory OBJECT IDENTIFIER

::= { standard 2 }

memoryAvailableBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Available Bytes is the amount of physical

memory available to processes running on the

computer, in bytes. It is calculated by

summing 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. "

::= { memory 1 }

memoryAvailableKBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Available KBytes is the amount of physical

memory available to processes running on the

computer, in Kilobytes (Bytes / 1,024). It is

calculated by summing 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. "

::= { memory 2 }

memoryAvailableMBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Available MBytes is the amount of physical

memory available to processes running on the

computer, in Megabytes (Bytes / 1,048,576). It

is calculated by summing 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. "

::= { memory 3 }

memoryCommittedBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Committed Bytes is the amount of committed

virtual memory, in bytes. (Committed memory is

physical memory for which space has been

reserved on the disk paging file in case it

needs to be written back to disk). This counter

displays the last observed value only; it is

not an average. "

::= { memory 4 }

memoryCacheBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Cache Bytes is the sum of the System Cache

Resident Bytes, System Driver Resident Bytes,

System Code Resident Bytes, and Pool Paged

Resident Bytes counters. This counter displays

the last observed value only; it is not an

average. "

::= { memory 5 }

memoryCacheBytesPeak OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Cache Bytes Peak is the maximum value of Cache

Bytes since the system was last restarted.

This value might be larger than the current

size of the cache. Cache Bytes is the sum of

the System Cache Resident Bytes, System Driver

Resident Bytes, System Code Resident Bytes, and

Pool Paged Resident Bytes counters. This

counter displays the last observed value only;

it is not an average. "

::= { memory 6 }

memoryPageFaultsPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Page Faults/sec is the overall rate faulted

pages are handled by the processor. It is

measured in numbers of pages faulted per

second. A page fault occurs when a process

requires code or data that is not in its

working set (its space in physical memory).

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

consequence. However, hard faults can cause

significant delays. This counter displays the

difference between the values observed in the

last two samples, divided by the duration of

the sample interval. "

::= { memory 7 }

memoryPagesInputPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Pages Input/sec is the number of pages read

from disk to resolve hard page faults. (Hard

page faults occur when a process requires code

or data that is not in its working set or

elsewhere in physical memory, and must be

retrieved from disk). This counter was designed

as a primary indicator of the kinds of faults

that cause system-wide delays. It includes

pages retrieved to satisfy faults in the file

system cache (usually requested by

applications) and in non-cached mapped memory

files. This counter counts numbers of pages,

and can be compared to other counts of pages,

such as Memory: Page Faults/sec, without

conversion. This counter displays the

difference between the values observed in the

last two samples, divided by the duration of

the sample interval. "

::= { memory 8 }

memoryPagesOutputPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Pages Output/sec is the number of pages

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 NT writes more pages back to

disk to free up space when physical memory is

in short supply. This counter counts numbers

of pages, and can be compared to other counts

of pages, without conversion. This counter

displays the difference between the values

observed in the last two samples, divided by

the duration of the sample interval. "

::= { memory 9 }

memoryPagesPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Pages/sec is the number of pages read from or

written to disk to resolve hard page faults.

(Hard page faults occur when a process requires

code or data that is not in its working set or

elsewhere in physical memory, and must be

retrieved from disk). This counter was designed

as 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. This counter displays the

difference between the values observed in the

last two samples, divided by the duration of

the sample interval. "

::= { memory 10 }

memoryPoolNonpagedBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Pool Nonpaged Bytes is the number of bytes in

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. "

::= { memory 11 }

memoryPoolPagedBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Pool Paged Bytes is the number of bytes in 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. "

::= { memory 12 }

memoryPoolPagedResidentBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Pool Paged Resident Bytes is the current size

of paged pool in bytes. 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. "

::= { memory 13 }

memorySystemCacheResidentBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Cache Resident Bytes is the number of

bytes from the file system cache that are

resident in physical memory. This value

includes only current physical pages and does

not include any virtual memory pages not

currently resident. As such 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. This counter displays the last

observed value only; it is not an average. "

::= { memory 14 }

memorySystemCodeResidentBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Code Resident Bytes is the number of

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 and cannot be written to disk.

This counter displays the last observed value

only; it is not an average. "

::= { memory 15 }

memorySystemCodeTotalBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Code Total Bytes is the number of 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 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. "

::= { memory 16 }

memorySystemDriverResidentBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Driver Resident Bytes is the number of

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 System

Driver Resident Bytes nor System Driver Total

Bytes includes memory that cannot be written to

disk."

::= { memory 17 }

memorySystemDriverTotalBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Driver Total Bytes is the number of

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

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. "

::= { memory 18 }

memoryCommittedKBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Committed KiloBytes is the amount of committed

virtual memory, in kilobytes. 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."

::= { memory 19 }

memoryCacheKBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Cache KiloBytes is the sum of the

Memory\\System Cache Resident KiloBytes,

Memory\\System Driver Resident KiloBytes,

Memory\\System Code Resident KiloBytes, and

Memory\\Pool Paged Resident KiloBytes counters.

This counter displays the last observed value

only; it is not an average. "

::= { memory 20 }

memoryCacheKBytesPeak OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Cache KiloBytes Peak is the maximum number of

kilobytes 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. "

::= { memory 21 }

memoryPoolNonpagedKBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Pool Nonpaged KiloBytes is the size, in

kilobytes, 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 KiloBytes is calculated

differently than Process\\Pool Nonpaged

KiloBytes, so it might not equal Process\\Pool

Nonpaged KiloBytes\\_Total. This counter

displays the last observed value only; it is

not an average."

::= { memory 22 }

memoryPoolPagedKBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Pool Paged KiloBytes is the size, in

kilobytes, 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 KiloBytes is calculated differently than

Process\\Pool Paged KiloBytes, so it might not

equal Process\\Pool Paged KiloBytes\\_Total.

This counter displays the last observed value

only; it is not an average."

::= { memory 23 }

memoryPoolPagedResidentKBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Pool Paged Resident KiloBytes is the current

size, in kilobytes, 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."

::= { memory 24 }

memorySystemCacheResidentKBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Cache Resident KiloBytes is the size,

in kilobytes, 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 KiloBytes 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. "

::= { memory 25 }

memorySystemCodeResidentKBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Code Resident KiloBytes is the size, in

kilobytes 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

KiloBytes, which also includes operating system

code on disk. Memory\\System Code Resident

KiloBytes (and Memory\\System Code Total

KiloBytes) 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."

::= { memory 26 }

memorySystemCodeTotalKBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Code Total KiloBytes is the size, in

kilobytes, 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 kilobytes 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."

::= { memory 27 }

memorySystemDriverResidentKBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Driver Resident KiloBytes is the size,

in kilobytes, 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 KiloBytes, which also includes driver

memory that has been written to disk. Neither

Memory\\System Driver Resident KiloBytes nor

Memory\\System Driver Total KiloBytes includes

memory that cannot be written to disk."

::= { memory 28 }

memorySystemDriverTotalKBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Driver Total KiloBytes is the size, in

kilobytes, 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 KiloBytes) and

code and data paged to disk. It is a component

of Memory\\System Code Total KiloBytes. This

counter displays the last observed value only;

it is not an average. "

::= { memory 29 }

memoryCommittedMBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Committed MegaBytes is the amount of committed

virtual memory, in megabytes. 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."

::= { memory 30 }

memoryCacheMBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Cache MegaBytes is the sum of the

Memory\\System Cache Resident MegaBytes,

Memory\\System Driver Resident MegaBytes,

Memory\\System Code Resident MegaBytes, and

Memory\\Pool Paged Resident MegaBytes counters.

This counter displays the last observed value

only; it is not an average. "

::= { memory 31 }

memoryCacheMBytesPeak OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Cache MegaBytes Peak is the maximum number of

megabytes 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. "

::= { memory 32 }

memoryPoolNonpagedMBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Pool Nonpaged MegaBytes is the size, in

megabytes, 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 MegaBytes is calculated

differently than Process\\Pool Nonpaged

MegaBytes, so it might not equal Process\\Pool

Nonpaged MegaBytes\\_Total. This counter

displays the last observed value only; it is

not an average."

::= { memory 33 }

memoryPoolPagedMBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Pool Paged MegaBytes is the size, in

megabytes, 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 MegaBytes is calculated differently than

Process\\Pool Paged MegaBytes, so it might not

equal Process\\Pool Paged MegaBytes\\_Total.

This counter displays the last observed value

only; it is not an average."

::= { memory 34 }

memoryPoolPagedResidentMBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Pool Paged Resident MegaBytes is the current

size, in megabytes, 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."

::= { memory 35 }

memorySystemCacheResidentMBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Cache Resident MegaBytes is the size,

in megabytes, 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 MegaBytes 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. "

::= { memory 36 }

memorySystemCodeResidentMBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Code Resident MegaBytes is the size, in

megabytes 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

MegaBytes, which also includes operating system

code on disk. Memory\\System Code Resident

MegaBytes (and Memory\\System Code Total

MegaBytes) 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."

::= { memory 37 }

memorySystemCodeTotalMBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Code Total MegaBytes is the size, in

megabytes, 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 megabytes 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."

::= { memory 38 }

memorySystemDriverResidentMBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Driver Resident MegaBytes is the size,

in megabytes, 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 MegaBytes, which also includes driver

memory that has been written to disk. Neither

Memory\\System Driver Resident MegaBytes nor

Memory\\System Driver Total MegaBytes includes

memory that cannot be written to disk."

::= { memory 39 }

memorySystemDriverTotalMBytes OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Driver Total MegaBytes is the size, in

megabytes, 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 MegaBytes) and

code and data paged to disk. It is a component

of Memory\\System Code Total MegaBytes. This

counter displays the last observed value only;

it is not an average. "

::= { memory 40 }

networkInterfaceTable OBJECT-TYPE

SYNTAX SEQUENCE OF NetworkInterfaceEntry

ACCESS not-accessible

STATUS mandatory

DESCRIPTION

"The Network Interface performance object

consists of counters that measure the rates at

which bytes and packets are sent and received

over a TCP/IP connection. It includes counters

that monitor connection errors. The Network

Interface counters display data about the

network adapters on the server computer. The

first instance of the Network Interface object

(Instance 1) that you see in System Monitor

represents the loopback. The loopback is a

local path through the protocol driver and the

network adapter. All other instances represent

installed network adapters."

::= { standard 3 }

networkInterfaceEntry OBJECT-TYPE

SYNTAX NetworkInterfaceEntry

ACCESS not-accessible

STATUS mandatory

DESCRIPTION

"Performance information for one particular

instance of 'Network Interface' object."

INDEX { netInstance }

::= { networkInterfaceTable 1 }

NetworkInterfaceEntry ::= SEQUENCE {

netInstance InstanceName,

netBytesReceivedPerSec Gauge,

netBytesSentPerSec Gauge,

netBytesTotalPerSec Gauge,

netCurrentBandwidth Gauge,

netOutputQueueLength Gauge,

netPacketsOutboundDiscarded Gauge,

netPacketsOutboundErrors Gauge,

netPacketsReceivedDiscarded Gauge,

netPacketsReceivedErrors Gauge,

netPacketsReceivedUnknown Gauge,

netPacketsReceivedPerSec Gauge,

netPacketsSentPerSec Gauge,

netPacketsPerSec Gauge

}

netInstance OBJECT-TYPE

SYNTAX InstanceName

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Instance name."

::= { networkInterfaceEntry 1 }

netBytesReceivedPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Bytes Received/sec is the rate at which bytes

are received on the interface, including

framing characters."

::= { networkInterfaceEntry 2 }

netBytesSentPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Bytes Sent/sec is the rate at which bytes are

sent on the interface, including framing

characters."

::= { networkInterfaceEntry 3 }

netBytesTotalPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Bytes Total/sec is the rate at which bytes are

sent and received on the interface, including

framing characters."

::= { networkInterfaceEntry 4 }

netCurrentBandwidth OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Current Bandwidth is an estimate of the

interface's current bandwidth in bits per

second (BPS). For interfaces that do not vary

in bandwidth or for those where no accurate

estimation can be made, this value is the

nominal bandwidth."

::= { networkInterfaceEntry 5 }

netOutputQueueLength OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Output Queue Length is the length of the

output packet queue (in packets). If this is

longer than 2, delays are being experienced and

the bottleneck should be found and eliminated

if possible. Since the requests are queued by

NDIS in this implementation, this will always

be 0."

::= { networkInterfaceEntry 6 }

netPacketsOutboundDiscarded OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Packets Outbound Discarded is the number of

outbound packets that were chosen to be

discarded even though no errors had been

detected to prevent their being transmitted.

One possible reason for discarding such a

packet could be to free up buffer space."

::= { networkInterfaceEntry 7 }

netPacketsOutboundErrors OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Packets Outbound Errors is the number of

outbound packets that could not be transmitted

because of errors."

::= { networkInterfaceEntry 8 }

netPacketsReceivedDiscarded OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Packets Received Discarded is the number of

inbound packets that were chosen to be

discarded even though no errors had been

detected to prevent their being deliverable to

a higher-layer protocol. One possible reason

for discarding such a packet could be to free

up buffer space."

::= { networkInterfaceEntry 9 }

netPacketsReceivedErrors OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Packets Received Errors is the number of

inbound packets that contained errors

preventing them from being deliverable to a

higher-layer protocol."

::= { networkInterfaceEntry 10 }

netPacketsReceivedUnknown OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Packets Received Unknown is the number of

packets received via the interface that were

discarded because of an unknown or unsupported

protocol."

::= { networkInterfaceEntry 11 }

netPacketsReceivedPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Packets Received/sec is the rate at which

packets are received on the network interface."

::= { networkInterfaceEntry 12 }

netPacketsSentPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Packets Sent/sec is the rate at which packets

are sent on the network interface."

::= { networkInterfaceEntry 13 }

netPacketsPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Packets/sec is the rate at which packets are

sent and received on the network interface."

::= { networkInterfaceEntry 14 }

objects OBJECT IDENTIFIER

::= { standard 4 }

objectsProcesses OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Processes is the number of processes in the

computer at the time of data collection.

Notice that this is an instantaneous count, not

an average over the time interval. Each

process represents the running of a program."

::= { objects 1 }

objectsThreads OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Threads is the number of threads in the

computer at the time of data collection.

Notice that this is an instantaneous count, not

an average over the time interval. A thread is

the basic executable entity that can execute

instructions in a processor."

::= { objects 2 }

processorTable OBJECT-TYPE

SYNTAX SEQUENCE OF ProcessorEntry

ACCESS not-accessible

STATUS mandatory

DESCRIPTION

"The Processor performance object consists of

counters that measure aspects of processor

activity. The processor is the part of the

computer that performs arithmetic and logical

computations, initiates operations on

peripherals, and runs the threads of processes.

A computer can have multiple processors. The

processor object represents each processor as

an instance of the object."

::= { standard 5 }

processorEntry OBJECT-TYPE

SYNTAX ProcessorEntry

ACCESS not-accessible

STATUS mandatory

DESCRIPTION

"Performance information for one particular

instance of 'Processor' object."

INDEX { cpuInstance }

::= { processorTable 1 }

ProcessorEntry ::= SEQUENCE {

cpuInstance InstanceName,

cpuPercentDPCTime Gauge,

cpuPercentInterruptTime Gauge,

cpuPercentPrivilegedTime Gauge,

cpuPercentProcessorTime Gauge,

cpuPercentUserTime Gauge,

cpuAPCBypassesPerSec Gauge,

cpuDPCBypassesPerSec Gauge,

cpuDPCRate Gauge,

cpuDPCsQueuedPerSec Gauge,

cpuInterruptsPerSec Gauge

}

cpuInstance OBJECT-TYPE

SYNTAX InstanceName

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Instance name."

::= { processorEntry 1 }

cpuPercentDPCTime OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"% DPC Time is the percentage of time that the

processor spent receiving and servicing

deferred procedure calls (DPCs) during the

sample interval. (DPCs are interrupts that run

at a lower priority than standard interrupts).

% DPC Time is a component of % Privileged Time

because DPCs are executed in privileged mode.

They are counted separately and are not a

component of the interrupt counters. This

counter displays the average busy time as a

percentage of the sample time. "

::= { processorEntry 2 }

cpuPercentInterruptTime OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"% Interrupt Time is the percentage of time the

processor spent receiving and servicing

hardware interrupts during the sample interval.

This value is an indirect indicator of the

activity of devices that generate interrupts,

such as the system clock, the mouse, disk

drivers, data communication lines, network

interface cards and other peripheral devices.

These devices normally interrupt the processor

when they have completed a task or require

attention. Normal thread execution is

suspended during interrupts. Most system

clocks interrupt the processor every 10

milliseconds, creating a background of

interrupt activity. This counter displays the

average busy time as a percentage of the sample

time. "

::= { processorEntry 3 }

cpuPercentPrivilegedTime OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"% Privileged Time is the percentage of

non-idle processor time spent in privileged

mode. (Privileged mode is a processing mode

designed for operating system components and

hardware-manipulating drivers. It allows

direct access to hardware and all memory. The

alternative, user mode, is a restricted

processing mode designed for applications,

environment subsystems, and integral

subsystems. The operating system switches

application threads to privileged mode to

access operating system services). % Privileged

Time includes time servicing interrupts and

DPCs. A high rate of privileged time might be

attributable to a large number of interrupts

generated by a failing device. This counter

displays the average busy time as a percentage

of the sample time. "

::= { processorEntry 4 }

cpuPercentProcessorTime OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"% Processor Time is the percentage of time

that the processor is executing a non-Idle

thread. This counter was designed as a primary

indicator of processor activity. It is

calculated by measuring the time that the

processor spends executing the thread of the

Idle process in each sample interval, and

subtracting that value from 100%. (Each

processor has an Idle thread which consumes

cycles when no other threads are ready to run).

It can be viewed as the percentage of the

sample interval spent doing useful work. This

counter displays the average percentage of busy

time observed during the sample interval. It

is calculated by monitoring the time the

service was inactive, and then subtracting that

value from 100%."

::= { processorEntry 5 }

cpuPercentUserTime OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"% User Time is the percentage of non-idle

processor time spent in user mode. (User mode

is a restricted processing mode designed for

applications, environment subsystems, and

integral subsystems. The alternative,

privileged mode, is designed for operating

system components and allows direct access to

hardware and all memory. The operating system

switches application threads to privileged mode

to access operating system services). This

counter displays the average busy time as a

percentage of the sample time. "

::= { processorEntry 6 }

cpuAPCBypassesPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"APC Bypasses/sec is the rate at which Kernel

APC interrupts were avoided. APC Bypasses/sec

is the rate at which kernel APC interrupts were

short-circuited. This counter displays the

difference between the values observed in the

last two samples, divided by the duration of

the sample interval."

::= { processorEntry 7 }

cpuDPCBypassesPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"DPC Bypasses/sec is the rate at which deferred

procedure calls (DPCs) on all processors were

avoided. (DPCs are interrupts that run at a

lower priority than standard interrupts). This

counter displays the difference between the

values observed in the last two samples,

divided by the duration of the sample

interval."

::= { processorEntry 8 }

cpuDPCRate OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"DPC Rate is the rate at which deferred

procedure calls (DPCs) are added to the

processor's DPC queue between the timer ticks

of the processor clock. (DPCs are interrupts

that run at a lower priority than standard

interrupts. Each processor has its own DPC

queue). This counter measures the rate at which

DPCs are added to the queue, not the number of

DPCs in the queue. This counter displays the

last observed value only; it is not an average."

::= { processorEntry 9 }

cpuDPCsQueuedPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"DPCs Queued/sec is the overall rate at which

deferred procedure calls (DPCs) are added to

the processor's DPC queue. (DPCs are

interrupts that run at a lower priority than

standard interrupts. Each processor has its

own DPC queue). This counter measures the rate

at which DPCs are added to the queue, not the

number of DPCs in the queue. This counter

displays the difference between the values

observed in the last two samples, divided by

the duration of the sample interval. "

::= { processorEntry 10 }

cpuInterruptsPerSec OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"Interrupts/sec is the average number of

hardware interrupts the processor is receiving

and servicing in each second. It does not

include DPCs, which are counted separately.

This value is an indirect indicator of the

activity of devices that generate interrupts,

such as the system clock, the mouse, disk

drivers, data communication lines, network

interface cards and other peripheral devices.

These devices normally interrupt the processor

when they have completed a task or require

attention. Normal thread execution is suspended

during interrupts. Most system clocks interrupt

the processor every 10 milliseconds, creating a

background of interrupt activity. This counter

displays the difference between the values

observed in the last two samples, divided by

the duration of the sample interval. "

::= { processorEntry 11 }

system OBJECT IDENTIFIER

::= { standard 6 }

systemSystemUpTime OBJECT-TYPE

SYNTAX Gauge

ACCESS read-only

STATUS mandatory

DESCRIPTION

"System Up Time is the elapsed time (in

seconds) that the computer has been running

since it was last started. This counter

displays the difference between the start time

and the current time. "

::= { system 1 }

END -- end of module INFORMANT-STD.

MIB v2

INFORMANT-STD DEFINITIONS ::= BEGIN

IMPORTS
    MODULE-IDENTITY, OBJECT-TYPE, OBJECT-IDENTITY, Gauge32
        FROM SNMPv2-SMI
    InstanceName, informant
        FROM WTCS;

standard MODULE-IDENTITY
    LAST-UPDATED "200807112359Z"
    ORGANIZATION "Informant Systems, Inc."
    CONTACT-INFO
            "Garth Williams
             11135-23A Ave
             Edmonton, AB  T6J4W5  Canada
             Tel: +1 780 434 4113
             E-mail: garth.williams@wtcs.org"
    DESCRIPTION
	    "The MIB module for SNMP Informant Standard
             performance counter entries."
    REVISION      "200807112359Z"
    DESCRIPTION
            "Multiplied lDiskAvgDiskSecPerRead,
            lDiskAvgDiskSecPerTransfer,
            lDiskAvgDiskSecPerWrite by 1000000 and
            lDiskAvgDiskQueueLength,
            lDiskAvgDiskReadQueueLength,
            lDiskAvgDiskWriteQueueLength by 1000 since these
            values are commonly fractional (less than 1)."
    REVISION      "200803212308Z"
    DESCRIPTION
	    "Added memory OIDs in kilobytes and megabytes
             to support 64-bit values in Gauge32."
    REVISION      "200507191826Z"
    DESCRIPTION
	    "Added the systemSystemUpTime OID to provide
	     access how long the computer has been up in
	     seconds."
    REVISION      "200402290627Z"
    DESCRIPTION
	    "Changed the syntax of the datapoints from
	     integer to gauge."
    REVISION      "200401171602Z"
    DESCRIPTION
            "The initial revision of this MIB module."
    ::= { informant 1 }

logicalDiskTable OBJECT-TYPE
    SYNTAX     SEQUENCE OF LogicalDiskEntry
    MAX-ACCESS not-accessible
    STATUS     current
    DESCRIPTION
	    "The Logical Disk performance object consists
	    of counters that monitor logical partitions of
	    hard or fixed disk drives. System Monitor
	    identifies logical disks by their drive letter,
	    such as 'C.' To monitor Logical Disk object
	    counters, you must activate them by typing the
	    following at the command prompt: diskperf -yv"
    ::= { standard 1 }

logicalDiskEntry OBJECT-TYPE
    SYNTAX     LogicalDiskEntry
    MAX-ACCESS not-accessible
    STATUS     current
    DESCRIPTION
	    "Performance information for one particular
	    instance of 'LogicalDisk' object."
    INDEX      { lDiskInstance }
    ::= { logicalDiskTable 1 }

LogicalDiskEntry ::= SEQUENCE {
    lDiskInstance InstanceName,
    lDiskPercentDiskReadTime Gauge32,
    lDiskPercentDiskTime Gauge32,
    lDiskPercentDiskWriteTime Gauge32,
    lDiskPercentFreeSpace Gauge32,
    lDiskPercentIdleTime Gauge32,
    lDiskAvgDiskQueueLength Gauge32,
    lDiskAvgDiskReadQueueLength Gauge32,
    lDiskAvgDiskWriteQueueLength Gauge32,
    lDiskAvgDiskSecPerRead Gauge32,
    lDiskAvgDiskSecPerTransfer Gauge32,
    lDiskAvgDiskSecPerWrite Gauge32,
    lDiskCurrentDiskQueueLength Gauge32,
    lDiskDiskBytesPerSec Gauge32,
    lDiskDiskReadBytesPerSec Gauge32,
    lDiskDiskReadsPerSec Gauge32,
    lDiskDiskTransfersPerSec Gauge32,
    lDiskDiskWriteBytesPerSec Gauge32,
    lDiskDiskWritesPerSec Gauge32,
    lDiskFreeMegabytes Gauge32,
    lDiskSplitIOPerSec Gauge32
}

lDiskInstance OBJECT-TYPE
    SYNTAX     InstanceName
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Instance name."
    ::= { logicalDiskEntry 1 }

lDiskPercentDiskReadTime OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "% Disk Read Time is the percentage of elapsed
	    time that the selected disk drive is busy
	    servicing read requests."
    ::= { logicalDiskEntry 2 }

lDiskPercentDiskTime OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "% Disk Time is the percentage of elapsed time
	    that the selected disk drive is busy servicing
	    read or write requests."
    ::= { logicalDiskEntry 3 }

lDiskPercentDiskWriteTime OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "% Disk Write Time is the percentage of elapsed
	    time that the selected disk drive is busy
	    servicing write requests."
    ::= { logicalDiskEntry 4 }

lDiskPercentFreeSpace OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "% Free Space is the ratio of the free space
	    available on the logical disk unit to the total
	    usable space provided by the selected logical
	    disk drive."
    ::= { logicalDiskEntry 5 }

lDiskPercentIdleTime OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "% Idle Time reports the percentage of time
	    during the sample interval that the disk was
	    idle."
    ::= { logicalDiskEntry 6 }

lDiskAvgDiskQueueLength OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Avg. Disk Queue Length is the average number
	    of both read and write requests that were
	    queued for the selected disk during the sample
	    interval.
	    
	    Multiplied by 1000 to provide a useful gauge
	    value since it is commonly a fractional value."
    ::= { logicalDiskEntry 7 }

lDiskAvgDiskReadQueueLength OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Avg. Disk Read Queue Length is the average
	    number of read requests that were queued for
	    the selected disk during the sample interval.
	    
	    Multiplied by 1000 to provide a useful gauge
	    value since it is commonly a fractional value."
    ::= { logicalDiskEntry 8 }

lDiskAvgDiskWriteQueueLength OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Avg. Disk Write Queue Length is the average
	    number of write requests that were queued for
	    the selected disk during the sample interval.
	    
	    Multiplied by 1000 to provide a useful gauge
	    value since it is commonly a fractional value."
    ::= { logicalDiskEntry 9 }

lDiskAvgDiskSecPerRead OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Avg. Disk sec/Read is the average time, in
	    seconds, of a read of data from the disk.
	    
	    Multiplied by 1000000 to provide a useful gauge
	    value since it is commonly a fractional value."
    ::= { logicalDiskEntry 10 }

lDiskAvgDiskSecPerTransfer OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Avg. Disk sec/Transfer is the time, in
	    seconds, of the average disk transfer.
	    
	    Multiplied by 1000000 to provide a useful gauge
	    value since it is commonly a fractional value."
    ::= { logicalDiskEntry 11 }

lDiskAvgDiskSecPerWrite OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Avg. Disk sec/Write is the average time, in
	    seconds, of a write of data to the disk.
	    
	    Multiplied by 1000000 to provide a useful gauge
	    value since it is commonly a fractional value."
    ::= { logicalDiskEntry 12 }

lDiskCurrentDiskQueueLength OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Current Disk Queue Length is the number of
	    requests outstanding on the disk at the time
	    the performance data is collected.	It includes
	    requests in service at the time of the
	    snapshot.  This is an instantaneous length, not
	    an average over the time interval. 
	    Multi-spindle disk devices can have multiple
	    requests active at one time, but other
	    concurrent requests are awaiting service.  This
	    counter might reflect a transitory high or low
	    queue length, but if there is a sustained load
	    on the disk drive, it is likely that this will
	    be consistently high.  Requests are
	    experiencing delays proportional to the length
	    of this queue minus the number of spindles on
	    the disks.	This difference should average less
	    than 2 for good performance."
    ::= { logicalDiskEntry 13 }

lDiskDiskBytesPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Disk Bytes/sec is the rate bytes are
	    transferred to or from the disk during write or
	    read operations."
    ::= { logicalDiskEntry 14 }

lDiskDiskReadBytesPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Disk Read Bytes/sec is the rate bytes are
	    transferred from the disk during read
	    operations."
    ::= { logicalDiskEntry 15 }

lDiskDiskReadsPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Disk Reads/sec is the rate of read operations
	    on the disk."
    ::= { logicalDiskEntry 16 }

lDiskDiskTransfersPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Disk Transfers/sec is the rate of read and
	    write operations on the disk."
    ::= { logicalDiskEntry 17 }

lDiskDiskWriteBytesPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Disk Write Bytes is rate bytes are transferred
	    to the disk during write operations."
    ::= { logicalDiskEntry 18 }

lDiskDiskWritesPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Disk Writes/sec is the rate of write
	    operations on the disk."
    ::= { logicalDiskEntry 19 }

lDiskFreeMegabytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Free Megabytes displays the unallocated space
	    on the disk drive in megabytes. One megabyte =
	    1,048,576 bytes."
    ::= { logicalDiskEntry 20 }

lDiskSplitIOPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Split IO/Sec reports the rate that I/Os to the
	    disk were split into multiple I/Os.  A split
	    I/O may result from requesting data in a size
	    that is too large to fit into a single I/O or
	    that the disk is fragmented."
    ::= { logicalDiskEntry 21 }

memory OBJECT-IDENTITY
    STATUS     current
    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
	    (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."
    ::= { standard 2 }

memoryAvailableBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Available Bytes is the amount of physical
	    memory available to processes running on the
	    computer, in bytes.  It is calculated by
	    summing 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. "
    ::= { memory 1 }

memoryAvailableKBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Available KBytes is the amount of physical
	    memory available to processes running on the
	    computer, in Kilobytes (Bytes / 1,024).  It is
	    calculated by summing 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. "
    ::= { memory 2 }

memoryAvailableMBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Available MBytes is the amount of physical
	    memory available to processes running on the
	    computer, in Megabytes (Bytes / 1,048,576).  It
	    is calculated by summing 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. "
    ::= { memory 3 }

memoryCommittedBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Committed Bytes is the amount of committed
	    virtual memory, in bytes.  (Committed memory is
	    physical memory for which space has been
	    reserved on the disk paging file in case it
	    needs to be written back to disk). This counter
	    displays the last observed value only; it is
	    not an average. "
    ::= { memory 4 }

memoryCacheBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Cache Bytes is the sum of the System Cache
	    Resident Bytes, System Driver Resident Bytes,
	    System Code Resident Bytes, and Pool Paged
	    Resident Bytes counters.  This counter displays
	    the last observed value only; it is not an
	    average. "
    ::= { memory 5 }

memoryCacheBytesPeak OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Cache Bytes Peak is the maximum value of Cache
	    Bytes since the system was last restarted. 
	    This value might be larger than the current
	    size of the cache.	Cache Bytes is the sum of
	    the System Cache Resident Bytes, System Driver
	    Resident Bytes, System Code Resident Bytes, and
	    Pool Paged Resident Bytes counters.  This
	    counter displays the last observed value only;
	    it is not an average. "
    ::= { memory 6 }

memoryPageFaultsPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Page Faults/sec is the overall rate faulted
	    pages are handled by the processor.  It is
	    measured in numbers of pages faulted per
	    second.  A page fault occurs when a process
	    requires code or data that is not in its
	    working set (its space in physical memory). 
	    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
	    consequence.  However, hard faults can cause
	    significant delays. This counter displays the
	    difference between the values observed in the
	    last two samples, divided by the duration of
	    the sample interval. "
    ::= { memory 7 }

memoryPagesInputPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Pages Input/sec is the number of pages read
	    from disk to resolve hard page faults.  (Hard
	    page faults occur when a process requires code
	    or data that is not in its working set or
	    elsewhere in physical memory, and must be
	    retrieved from disk). This counter was designed
	    as a primary indicator of the kinds of faults
	    that cause system-wide delays.  It includes
	    pages retrieved to satisfy faults in the file
	    system cache (usually requested by
	    applications) and in non-cached mapped memory
	    files.  This counter counts numbers of pages,
	    and can be compared to other counts of pages,
	    such as Memory: Page Faults/sec, without
	    conversion.  This counter displays the
	    difference between the values observed in the
	    last two samples, divided by the duration of
	    the sample interval. "
    ::= { memory 8 }

memoryPagesOutputPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Pages Output/sec is the number of pages
	    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 NT writes more pages back to
	    disk to free up space when physical memory is
	    in short supply.  This counter counts numbers
	    of pages, and can be compared to other counts
	    of pages, without conversion.  This counter
	    displays the difference between the values
	    observed in the last two samples, divided by
	    the duration of the sample interval. "
    ::= { memory 9 }

memoryPagesPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Pages/sec is the number of pages read from or
	    written to disk to resolve hard page faults. 
	    (Hard page faults occur when a process requires
	    code or data that is not in its working set or
	    elsewhere in physical memory, and must be
	    retrieved from disk). This counter was designed
	    as 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.  This counter displays the
	    difference between the values observed in the
	    last two samples, divided by the duration of
	    the sample interval. "
    ::= { memory 10 }

memoryPoolNonpagedBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Pool Nonpaged Bytes is the number of bytes in
	    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.  "
    ::= { memory 11 }

memoryPoolPagedBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Pool Paged Bytes is the number of bytes in 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.  "
    ::= { memory 12 }

memoryPoolPagedResidentBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Pool Paged Resident Bytes is the current size
	    of paged pool in bytes.  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. "
    ::= { memory 13 }

memorySystemCacheResidentBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Cache Resident Bytes is the number of
	    bytes from the file system cache that are
	    resident in physical memory.  This value
	    includes only current physical pages and does
	    not include any virtual memory pages not
	    currently resident.  As such 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.  This counter displays the last
	    observed value only; it is not an average. "
    ::= { memory 14 }

memorySystemCodeResidentBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Code Resident Bytes is the number of
	    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 and cannot be written to disk. 
	    This counter displays the last observed value
	    only; it is not an average.  "
    ::= { memory 15 }

memorySystemCodeTotalBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Code Total Bytes is the number of 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 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. "
    ::= { memory 16 }

memorySystemDriverResidentBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Driver Resident Bytes is the number of
	    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 System
	    Driver Resident Bytes nor System Driver Total
	    Bytes includes memory that cannot be written to
	    disk."
    ::= { memory 17 }

memorySystemDriverTotalBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Driver Total Bytes is the number of
	    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
	    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.  "
    ::= { memory 18 }

memoryCommittedKBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Committed KiloBytes is the amount of committed
	    virtual memory, in kilobytes. 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."
    ::= { memory 19 }

memoryCacheKBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Cache KiloBytes is the sum of the
	    Memory\\System Cache Resident KiloBytes,
	    Memory\\System Driver Resident KiloBytes,
	    Memory\\System Code Resident KiloBytes, and
	    Memory\\Pool Paged Resident KiloBytes counters.
	     This counter displays the last observed value
	    only; it is not an average. "
    ::= { memory 20 }

memoryCacheKBytesPeak OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Cache KiloBytes Peak is the maximum number of
	    kilobytes 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. "
    ::= { memory 21 }

memoryPoolNonpagedKBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Pool Nonpaged KiloBytes is the size, in
	    kilobytes, 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 KiloBytes is calculated
	    differently than Process\\Pool Nonpaged
	    KiloBytes, so it might not equal Process\\Pool
	    Nonpaged KiloBytes\\_Total.  This counter
	    displays the last observed value only; it is
	    not an average."
    ::= { memory 22 }

memoryPoolPagedKBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Pool Paged KiloBytes is the size, in
	    kilobytes, 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 KiloBytes is calculated differently than
	    Process\\Pool Paged KiloBytes, so it might not
	    equal Process\\Pool Paged KiloBytes\\_Total.
	    This counter displays the last observed value
	    only; it is not an average."
    ::= { memory 23 }

memoryPoolPagedResidentKBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Pool Paged Resident KiloBytes is the current
	    size, in kilobytes, 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."
    ::= { memory 24 }

memorySystemCacheResidentKBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Cache Resident KiloBytes is the size,
	    in kilobytes, 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 KiloBytes 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. "
    ::= { memory 25 }

memorySystemCodeResidentKBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Code Resident KiloBytes is the size, in
	    kilobytes 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
	    KiloBytes, which also includes operating system
	    code on disk. Memory\\System Code Resident
	    KiloBytes (and Memory\\System Code Total
	    KiloBytes) 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."
    ::= { memory 26 }

memorySystemCodeTotalKBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Code Total KiloBytes is the size, in
	    kilobytes, 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 kilobytes 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."
    ::= { memory 27 }

memorySystemDriverResidentKBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Driver Resident KiloBytes is the size,
	    in kilobytes, 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 KiloBytes, which also includes driver
	    memory that has been written to disk. Neither
	    Memory\\System Driver Resident KiloBytes nor
	    Memory\\System Driver Total KiloBytes includes
	    memory that cannot be written to disk."
    ::= { memory 28 }

memorySystemDriverTotalKBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Driver Total KiloBytes is the size, in
	    kilobytes, 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 KiloBytes) and
	    code and data paged to disk. It is a component
	    of Memory\\System Code Total KiloBytes. This
	    counter displays the last observed value only;
	    it is not an average.  "
    ::= { memory 29 }

memoryCommittedMBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Committed MegaBytes is the amount of committed
	    virtual memory, in megabytes. 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."
    ::= { memory 30 }

memoryCacheMBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Cache MegaBytes is the sum of the
	    Memory\\System Cache Resident MegaBytes,
	    Memory\\System Driver Resident MegaBytes,
	    Memory\\System Code Resident MegaBytes, and
	    Memory\\Pool Paged Resident MegaBytes counters.
	     This counter displays the last observed value
	    only; it is not an average. "
    ::= { memory 31 }

memoryCacheMBytesPeak OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Cache MegaBytes Peak is the maximum number of
	    megabytes 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. "
    ::= { memory 32 }

memoryPoolNonpagedMBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Pool Nonpaged MegaBytes is the size, in
	    megabytes, 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 MegaBytes is calculated
	    differently than Process\\Pool Nonpaged
	    MegaBytes, so it might not equal Process\\Pool
	    Nonpaged MegaBytes\\_Total.  This counter
	    displays the last observed value only; it is
	    not an average."
    ::= { memory 33 }

memoryPoolPagedMBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Pool Paged MegaBytes is the size, in
	    megabytes, 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 MegaBytes is calculated differently than
	    Process\\Pool Paged MegaBytes, so it might not
	    equal Process\\Pool Paged MegaBytes\\_Total.
	    This counter displays the last observed value
	    only; it is not an average."
    ::= { memory 34 }

memoryPoolPagedResidentMBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Pool Paged Resident MegaBytes is the current
	    size, in megabytes, 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."
    ::= { memory 35 }

memorySystemCacheResidentMBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Cache Resident MegaBytes is the size,
	    in megabytes, 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 MegaBytes 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. "
    ::= { memory 36 }

memorySystemCodeResidentMBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Code Resident MegaBytes is the size, in
	    megabytes 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
	    MegaBytes, which also includes operating system
	    code on disk. Memory\\System Code Resident
	    MegaBytes (and Memory\\System Code Total
	    MegaBytes) 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."
    ::= { memory 37 }

memorySystemCodeTotalMBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Code Total MegaBytes is the size, in
	    megabytes, 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 megabytes 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."
    ::= { memory 38 }

memorySystemDriverResidentMBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Driver Resident MegaBytes is the size,
	    in megabytes, 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 MegaBytes, which also includes driver
	    memory that has been written to disk. Neither
	    Memory\\System Driver Resident MegaBytes nor
	    Memory\\System Driver Total MegaBytes includes
	    memory that cannot be written to disk."
    ::= { memory 39 }

memorySystemDriverTotalMBytes OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Driver Total MegaBytes is the size, in
	    megabytes, 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 MegaBytes) and
	    code and data paged to disk. It is a component
	    of Memory\\System Code Total MegaBytes. This
	    counter displays the last observed value only;
	    it is not an average.  "
    ::= { memory 40 }

networkInterfaceTable OBJECT-TYPE
    SYNTAX     SEQUENCE OF NetworkInterfaceEntry
    MAX-ACCESS not-accessible
    STATUS     current
    DESCRIPTION
	    "The Network Interface performance object
	    consists of counters that measure the rates at
	    which bytes and packets are sent and received
	    over a TCP/IP connection. It includes counters
	    that monitor connection errors. The Network
	    Interface counters display data about the
	    network adapters on the server computer. The
	    first instance of the Network Interface object
	    (Instance 1) that you see in System Monitor
	    represents the loopback. The loopback is a
	    local path through the protocol driver and the
	    network adapter. All other instances represent
	    installed network adapters."
    ::= { standard 3 }

networkInterfaceEntry OBJECT-TYPE
    SYNTAX     NetworkInterfaceEntry
    MAX-ACCESS not-accessible
    STATUS     current
    DESCRIPTION
	    "Performance information for one particular
	    instance of 'Network Interface' object."
    INDEX      { netInstance }
    ::= { networkInterfaceTable 1 }

NetworkInterfaceEntry ::= SEQUENCE {
    netInstance InstanceName,
    netBytesReceivedPerSec Gauge32,
    netBytesSentPerSec Gauge32,
    netBytesTotalPerSec Gauge32,
    netCurrentBandwidth Gauge32,
    netOutputQueueLength Gauge32,
    netPacketsOutboundDiscarded Gauge32,
    netPacketsOutboundErrors Gauge32,
    netPacketsReceivedDiscarded Gauge32,
    netPacketsReceivedErrors Gauge32,
    netPacketsReceivedUnknown Gauge32,
    netPacketsReceivedPerSec Gauge32,
    netPacketsSentPerSec Gauge32,
    netPacketsPerSec Gauge32
}

netInstance OBJECT-TYPE
    SYNTAX     InstanceName
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Instance name."
    ::= { networkInterfaceEntry 1 }

netBytesReceivedPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Bytes Received/sec is the rate at which bytes
	    are received on the interface, including
	    framing characters."
    ::= { networkInterfaceEntry 2 }

netBytesSentPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Bytes Sent/sec is the rate at which bytes are
	    sent on the interface, including framing
	    characters."
    ::= { networkInterfaceEntry 3 }

netBytesTotalPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Bytes Total/sec is the rate at which bytes are
	    sent and received on the interface, including
	    framing characters."
    ::= { networkInterfaceEntry 4 }

netCurrentBandwidth OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Current Bandwidth is an estimate of the
	    interface's current bandwidth in bits per
	    second (BPS).  For interfaces that do not vary
	    in bandwidth or for those where no accurate
	    estimation can be made, this value is the
	    nominal bandwidth."
    ::= { networkInterfaceEntry 5 }

netOutputQueueLength OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Output Queue Length is the length of the
	    output packet queue (in packets).  If this is
	    longer than 2, delays are being experienced and
	    the bottleneck should be found and eliminated
	    if possible.  Since the requests are queued by
	    NDIS in this implementation, this will always
	    be 0."
    ::= { networkInterfaceEntry 6 }

netPacketsOutboundDiscarded OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Packets Outbound Discarded is the number of
	    outbound packets that were chosen to be
	    discarded even though no errors had been
	    detected to prevent their being transmitted. 
	    One possible reason for discarding such a
	    packet could be to free up buffer space."
    ::= { networkInterfaceEntry 7 }

netPacketsOutboundErrors OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Packets Outbound Errors is the number of
	    outbound packets that could not be transmitted
	    because of errors."
    ::= { networkInterfaceEntry 8 }

netPacketsReceivedDiscarded OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Packets Received Discarded is the number of
	    inbound packets that were chosen to be
	    discarded even though no errors had been
	    detected to prevent their being deliverable to
	    a higher-layer protocol.  One possible reason
	    for discarding such a packet could be to free
	    up buffer space."
    ::= { networkInterfaceEntry 9 }

netPacketsReceivedErrors OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Packets Received Errors is the number of
	    inbound packets that contained errors
	    preventing them from being deliverable to a
	    higher-layer protocol."
    ::= { networkInterfaceEntry 10 }

netPacketsReceivedUnknown OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Packets Received Unknown is the number of
	    packets received via the interface that were
	    discarded because of an unknown or unsupported
	    protocol."
    ::= { networkInterfaceEntry 11 }

netPacketsReceivedPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Packets Received/sec is the rate at which
	    packets are received on the network interface."
    ::= { networkInterfaceEntry 12 }

netPacketsSentPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Packets Sent/sec is the rate at which packets
	    are sent on the network interface."
    ::= { networkInterfaceEntry 13 }

netPacketsPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Packets/sec is the rate at which packets are
	    sent and received on the network interface."
    ::= { networkInterfaceEntry 14 }

objects OBJECT-IDENTITY
    STATUS     current
    DESCRIPTION
	    "The Objects performance object consists of
	    counters that monitor logical objects in the
	    system, such as processes, threads, mutexes,
	    and semaphores. This information can be used to
	    detect the unnecessary consumption of computer
	    resources. Each object requires memory to store
	    basic information about the object."
    ::= { standard 4 }

objectsProcesses OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Processes is the number of processes in the
	    computer at the time of data collection. 
	    Notice that this is an instantaneous count, not
	    an average over the time interval.	Each
	    process represents the running of a program."
    ::= { objects 1 }

objectsThreads OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Threads is the number of threads in the
	    computer at the time of data collection. 
	    Notice that this is an instantaneous count, not
	    an average over the time interval.	A thread is
	    the basic executable entity that can execute
	    instructions in a processor."
    ::= { objects 2 }

processorTable OBJECT-TYPE
    SYNTAX     SEQUENCE OF ProcessorEntry
    MAX-ACCESS not-accessible
    STATUS     current
    DESCRIPTION
	    "The Processor performance object consists of
	    counters that measure aspects of processor
	    activity. The processor is the part of the
	    computer that performs arithmetic and logical
	    computations, initiates operations on
	    peripherals, and runs the threads of processes.
	    A computer can have multiple processors. The
	    processor object represents each processor as
	    an instance of the object."
    ::= { standard 5 }

processorEntry OBJECT-TYPE
    SYNTAX     ProcessorEntry
    MAX-ACCESS not-accessible
    STATUS     current
    DESCRIPTION
	    "Performance information for one particular
	    instance of 'Processor' object."
    INDEX      { cpuInstance }
    ::= { processorTable 1 }

ProcessorEntry ::= SEQUENCE {
    cpuInstance InstanceName,
    cpuPercentDPCTime Gauge32,
    cpuPercentInterruptTime Gauge32,
    cpuPercentPrivilegedTime Gauge32,
    cpuPercentProcessorTime Gauge32,
    cpuPercentUserTime Gauge32,
    cpuAPCBypassesPerSec Gauge32,
    cpuDPCBypassesPerSec Gauge32,
    cpuDPCRate Gauge32,
    cpuDPCsQueuedPerSec Gauge32,
    cpuInterruptsPerSec Gauge32
}

cpuInstance OBJECT-TYPE
    SYNTAX     InstanceName
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Instance name."
    ::= { processorEntry 1 }

cpuPercentDPCTime OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "% DPC Time is the percentage of time that the
	    processor spent receiving and servicing
	    deferred procedure calls (DPCs) during the
	    sample interval.  (DPCs are interrupts that run
	    at a lower priority than standard interrupts).
	    % DPC Time is a component of % Privileged Time
	    because DPCs are executed in privileged mode. 
	    They are counted separately and are not a
	    component of the interrupt counters.  This
	    counter displays the average busy time as a
	    percentage of the sample time. "
    ::= { processorEntry 2 }

cpuPercentInterruptTime OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "% Interrupt Time is the percentage of time the
	    processor spent receiving and servicing
	    hardware interrupts during the sample interval.
	     This value is an indirect indicator of the
	    activity of devices that generate interrupts,
	    such as the system clock, the mouse, disk
	    drivers, data communication lines, network
	    interface cards and other peripheral devices.
	    These devices normally interrupt the processor
	    when they have completed a task or require
	    attention.	Normal thread execution is
	    suspended during interrupts.  Most system
	    clocks interrupt the processor every 10
	    milliseconds, creating a background of
	    interrupt activity.  This counter displays the
	    average busy time as a percentage of the sample
	    time. "
    ::= { processorEntry 3 }

cpuPercentPrivilegedTime OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "% Privileged Time is the percentage of
	    non-idle processor time spent in privileged
	    mode.  (Privileged mode is a processing mode
	    designed for operating system components and
	    hardware-manipulating drivers.  It allows
	    direct access to hardware and all memory.  The
	    alternative, user mode, is a restricted
	    processing mode designed for applications,
	    environment subsystems, and integral
	    subsystems.  The operating system switches
	    application threads to privileged mode to
	    access operating system services). % Privileged
	    Time includes time servicing interrupts and
	    DPCs.  A high rate of privileged time might be
	    attributable to a large number of interrupts
	    generated by a failing device.  This counter
	    displays the average busy time as a percentage
	    of the sample time. "
    ::= { processorEntry 4 }

cpuPercentProcessorTime OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "% Processor Time is the percentage of time
	    that the processor is executing a non-Idle
	    thread.  This counter was designed as a primary
	    indicator of processor activity.  It is
	    calculated by measuring the time that the
	    processor spends executing the thread of the
	    Idle process in each sample interval, and
	    subtracting that value from 100%.  (Each
	    processor has an Idle thread which consumes
	    cycles when no other threads are ready to run).
	    It can be viewed as the percentage of the
	    sample interval spent doing useful work.  This
	    counter displays the average percentage of busy
	    time observed during the sample interval.  It
	    is calculated by monitoring the time the
	    service was inactive, and then subtracting that
	    value from 100%."
    ::= { processorEntry 5 }

cpuPercentUserTime OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "% User Time is the percentage of non-idle
	    processor time spent in user mode.	(User mode
	    is a restricted processing mode designed for
	    applications, environment subsystems, and
	    integral subsystems.  The alternative,
	    privileged mode, is designed for operating
	    system components and allows direct access to
	    hardware and all memory.  The operating system
	    switches application threads to privileged mode
	    to access operating system services). This
	    counter displays the average busy time as a
	    percentage of the sample time. "
    ::= { processorEntry 6 }

cpuAPCBypassesPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "APC Bypasses/sec is the rate at which Kernel
	    APC interrupts were avoided.  APC Bypasses/sec
	    is the rate at which kernel APC interrupts were
	    short-circuited.  This counter displays the
	    difference between the values observed in the
	    last two samples, divided by the duration of
	    the sample interval."
    ::= { processorEntry 7 }

cpuDPCBypassesPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "DPC Bypasses/sec is the rate at which deferred
	    procedure calls (DPCs) on all processors were
	    avoided.  (DPCs are interrupts that run at a
	    lower priority than standard interrupts). This
	    counter displays the difference between the
	    values observed in the last two samples,
	    divided by the duration of the sample
	    interval."
    ::= { processorEntry 8 }

cpuDPCRate OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "DPC Rate is the rate at which deferred
	    procedure calls (DPCs) are added to the
	    processor's DPC queue between the timer ticks
	    of the processor clock.  (DPCs are interrupts
	    that run at a lower priority than standard
	    interrupts.  Each processor has its own DPC
	    queue). This counter measures the rate at which
	    DPCs are added to the queue, not the number of
	    DPCs in the queue.	This counter displays the
	    last observed value only; it is not an average.
	    "
    ::= { processorEntry 9 }

cpuDPCsQueuedPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "DPCs Queued/sec is the overall rate at which
	    deferred procedure calls (DPCs) are added to
	    the processor's DPC queue.	(DPCs are
	    interrupts that run at a lower priority than
	    standard interrupts.  Each processor has its
	    own DPC queue). This counter measures the rate
	    at which DPCs are added to the queue, not the
	    number of DPCs in the queue.  This counter
	    displays the difference between the values
	    observed in the last two samples, divided by
	    the duration of the sample interval. "
    ::= { processorEntry 10 }

cpuInterruptsPerSec OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "Interrupts/sec is the average number of
	    hardware interrupts the processor is receiving
	    and servicing in each second. It does not
	    include DPCs, which are counted separately.
	    This value is an indirect indicator of the
	    activity of devices that generate interrupts,
	    such as the system clock, the mouse, disk
	    drivers, data communication lines, network
	    interface cards and other peripheral devices.
	    These devices normally interrupt the processor
	    when they have completed a task or require
	    attention. Normal thread execution is suspended
	    during interrupts. Most system clocks interrupt
	    the processor every 10 milliseconds, creating a
	    background of interrupt activity. This counter
	    displays the difference between the values
	    observed in the last two samples, divided by
	    the duration of the sample interval. "
    ::= { processorEntry 11 }

system OBJECT-IDENTITY
    STATUS     current
    DESCRIPTION
	    "The System performance object consists of
	    counters that apply to more than one component
	    of the computer. Percentage counters by default
	    do not show values above 100 percent. See
	    'Overview of Performance Monitoring' in the
	    Windows 2000 Server Resource Kit Server
	    Operations Guide for instructions about
	    changing this default in the registry."
    ::= { standard 6 }

systemSystemUpTime OBJECT-TYPE
    SYNTAX     Gauge32
    MAX-ACCESS read-only
    STATUS     current
    DESCRIPTION
	    "System Up Time is the elapsed time (in
	    seconds) that the computer has been running
	    since it was last started.	This counter
	    displays the difference between the start time
	    and the current time. "
    ::= { system 1 }

END

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

1001

1002

1003

1004

1005

1006

1007

1008

1009

1010

1011

1012

1013

1014

1015

1016

1017

1018

1019

1020

1021

1022

1023

1024

1025

1026

1027

1028

1029

1030

1031

1032

1033

1034

1035

1036

1037

1038

1039

1040

1041

1042

1043

1044

1045

1046

1047

1048

1049

1050

1051

1052

1053

1054

1055

1056

1057

1058

1059

1060

1061

1062

1063

1064

1065

1066

1067

1068

1069

1070

1071

1072

1073

1074

1075

1076

1077

1078

1079

1080

1081

1082

1083

1084

1085

1086

1087

1088

1089

1090

1091

1092

1093

1094

1095

1096

1097

1098

1099

1100

1101

1102

1103

1104

1105

1106

1107

1108

1109

1110

1111

1112

1113

1114

1115

1116

1117

1118

1119

1120

1121

1122

1123

1124

1125

1126

1127

1128

1129

1130

1131

1132

1133

1134

1135

1136

1137

1138

1139

1140

1141

1142

1143

1144

1145

1146

1147

1148

1149

1150

1151

1152

1153

1154

1155

1156

1157

1158

1159

1160

1161

1162

1163

1164

1165

1166

1167

1168

1169

1170

1171

1172

1173

1174

1175

1176

1177

1178

1179

1180

1181

1182

1183

1184

1185

1186

1187

1188

1189

1190

1191

1192

1193

1194

1195

1196

1197

1198

1199

1200

1201

1202

1203

1204

1205

1206

1207

1208

1209

1210

1211

1212

1213

1214

1215

1216

1217

1218

1219

1220

1221

1222

1223

1224

1225

1226

1227

1228

1229

1230

1231

1232

1233

1234

1235

1236

1237

1238

1239

1240

1241

1242

1243

1244

1245

1246

1247

1248

1249

1250

1251

1252

1253

1254

1255

1256

1257

1258

1259

1260

1261

1262

1263

1264

1265

1266

1267

1268

1269

1270

1271

1272

1273

1274

1275

1276

1277

1278

1279

1280

1281

1282

1283

1284

1285

1286

1287

1288

1289

1290

1291

1292

1293

1294

1295

1296

1297

1298

1299

1300

1301

1302

1303

1304

1305

1306

1307

1308

1309

1310

1311

1312

1313

1314

1315

1316

1317

1318

1319

1320

1321

1322

1323

1324

1325

1326

1327

1328

1329

1330

1331

1332

1333

1334

1335

1336

1337

1338

1339

1340

1341

1342

1343

1344

1345

1346

1347

1348

1349

1350

1351

1352

1353

1354

1355

1356

1357

1358

1359

1360

1361

1362

1363

1364

1365

1366

1367

1368

1369

1370

1371

1372

1373

1374

1375

1376

1377

1378

1379

1380

1381

1382

1383

1384

1385

1386

1387

1388

1389

1390

1391

1392

1393

1394

1395

1396

1397

1398

1399

1400

1401

1402

1403

1404

1405

1406

1407

1408

1409

1410

1411

1412

1413

1414

1415

1416

1417

1418

1419

1420

1421

1422

1423

1424

1425

1426

1427

1428

1429

1430

1431

1432

1433

1434

1435

1436

1437

1438

1439

1440

1441

1442

1443

1444

1445

1446

1447

1448

1449

1450

1451

1452

1453

1454

1455

1456

1457

1458

1459

1460

1461

1462

1463

1464

1465

1466

1467

1468

1469

1470

1471

1472

1473

1474

1475

1476

1477

1478

1479

1480

1481

1482

1483

1484

1485

1486

1487

1488

1489

1490

1491

1492

1493

1494

1495

1496

1497

1498

1499

1500

1501

1502

1503

1504

1505

1506

1507

1508

1509

1510

1511

1512

1513

1514

1515

1516

1517

1518

1519

1520

1521

1522

1523

1524

1525

1526

1527

1528

1529

1530

1531

1532

1533

1534

1535

1536

1537

1538

1539

1540

1541

1542

1543

1544

1545

1546

1547

1548

1549

1550

1551

1552

1553

1554

1555

1556

1557

1558

1559

1560

1561

1562

1563

1564

1565

1566

1567

1568

1569

1570

1571

1572

1573

1574

1575

1576

1577

INFORMANT-STD DEFINITIONS ::= BEGIN

IMPORTS

MODULE-IDENTITY, OBJECT-TYPE, OBJECT-IDENTITY, Gauge32

FROM SNMPv2-SMI

InstanceName, informant

FROM WTCS;

standard MODULE-IDENTITY

LAST-UPDATED "200807112359Z"

ORGANIZATION "Informant Systems, Inc."

CONTACT-INFO

"Garth Williams

11135-23A Ave

Edmonton, AB T6J4W5 Canada

Tel: +1 780 434 4113

E-mail: garth.williams@wtcs.org"

DESCRIPTION

"The MIB module for SNMP Informant Standard

performance counter entries."

REVISION "200807112359Z"

DESCRIPTION

"Multiplied lDiskAvgDiskSecPerRead,

lDiskAvgDiskSecPerTransfer,

lDiskAvgDiskSecPerWrite by 1000000 and

lDiskAvgDiskQueueLength,

lDiskAvgDiskReadQueueLength,

lDiskAvgDiskWriteQueueLength by 1000 since these

values are commonly fractional (less than 1)."

REVISION "200803212308Z"

DESCRIPTION

"Added memory OIDs in kilobytes and megabytes

to support 64-bit values in Gauge32."

REVISION "200507191826Z"

DESCRIPTION

"Added the systemSystemUpTime OID to provide

access how long the computer has been up in

seconds."

REVISION "200402290627Z"

DESCRIPTION

"Changed the syntax of the datapoints from

integer to gauge."

REVISION "200401171602Z"

DESCRIPTION

"The initial revision of this MIB module."

::= { informant 1 }

logicalDiskTable OBJECT-TYPE

SYNTAX SEQUENCE OF LogicalDiskEntry

MAX-ACCESS not-accessible

STATUS current

DESCRIPTION

"The Logical Disk performance object consists

of counters that monitor logical partitions of

hard or fixed disk drives. System Monitor

identifies logical disks by their drive letter,

such as 'C.' To monitor Logical Disk object

counters, you must activate them by typing the

following at the command prompt: diskperf -yv"

::= { standard 1 }

logicalDiskEntry OBJECT-TYPE

SYNTAX LogicalDiskEntry

MAX-ACCESS not-accessible

STATUS current

DESCRIPTION

"Performance information for one particular

instance of 'LogicalDisk' object."

INDEX { lDiskInstance }

::= { logicalDiskTable 1 }

LogicalDiskEntry ::= SEQUENCE {

lDiskInstance InstanceName,

lDiskPercentDiskReadTime Gauge32,

lDiskPercentDiskTime Gauge32,

lDiskPercentDiskWriteTime Gauge32,

lDiskPercentFreeSpace Gauge32,

lDiskPercentIdleTime Gauge32,

lDiskAvgDiskQueueLength Gauge32,

lDiskAvgDiskReadQueueLength Gauge32,

lDiskAvgDiskWriteQueueLength Gauge32,

lDiskAvgDiskSecPerRead Gauge32,

lDiskAvgDiskSecPerTransfer Gauge32,

lDiskAvgDiskSecPerWrite Gauge32,

lDiskCurrentDiskQueueLength Gauge32,

lDiskDiskBytesPerSec Gauge32,

lDiskDiskReadBytesPerSec Gauge32,

lDiskDiskReadsPerSec Gauge32,

lDiskDiskTransfersPerSec Gauge32,

lDiskDiskWriteBytesPerSec Gauge32,

lDiskDiskWritesPerSec Gauge32,

lDiskFreeMegabytes Gauge32,

lDiskSplitIOPerSec Gauge32

}

lDiskInstance OBJECT-TYPE

SYNTAX InstanceName

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Instance name."

::= { logicalDiskEntry 1 }

lDiskPercentDiskReadTime OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"% Disk Read Time is the percentage of elapsed

time that the selected disk drive is busy

servicing read requests."

::= { logicalDiskEntry 2 }

lDiskPercentDiskTime OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"% Disk Time is the percentage of elapsed time

that the selected disk drive is busy servicing

read or write requests."

::= { logicalDiskEntry 3 }

lDiskPercentDiskWriteTime OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"% Disk Write Time is the percentage of elapsed

time that the selected disk drive is busy

servicing write requests."

::= { logicalDiskEntry 4 }

lDiskPercentFreeSpace OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"% Free Space is the ratio of the free space

available on the logical disk unit to the total

usable space provided by the selected logical

disk drive."

::= { logicalDiskEntry 5 }

lDiskPercentIdleTime OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"% Idle Time reports the percentage of time

during the sample interval that the disk was

idle."

::= { logicalDiskEntry 6 }

lDiskAvgDiskQueueLength OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Avg. Disk Queue Length is the average number

of both read and write requests that were

queued for the selected disk during the sample

interval.

Multiplied by 1000 to provide a useful gauge

value since it is commonly a fractional value."

::= { logicalDiskEntry 7 }

lDiskAvgDiskReadQueueLength OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Avg. Disk Read Queue Length is the average

number of read requests that were queued for

the selected disk during the sample interval.

Multiplied by 1000 to provide a useful gauge

value since it is commonly a fractional value."

::= { logicalDiskEntry 8 }

lDiskAvgDiskWriteQueueLength OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Avg. Disk Write Queue Length is the average

number of write requests that were queued for

the selected disk during the sample interval.

Multiplied by 1000 to provide a useful gauge

value since it is commonly a fractional value."

::= { logicalDiskEntry 9 }

lDiskAvgDiskSecPerRead OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Avg. Disk sec/Read is the average time, in

seconds, of a read of data from the disk.

Multiplied by 1000000 to provide a useful gauge

value since it is commonly a fractional value."

::= { logicalDiskEntry 10 }

lDiskAvgDiskSecPerTransfer OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Avg. Disk sec/Transfer is the time, in

seconds, of the average disk transfer.

Multiplied by 1000000 to provide a useful gauge

value since it is commonly a fractional value."

::= { logicalDiskEntry 11 }

lDiskAvgDiskSecPerWrite OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Avg. Disk sec/Write is the average time, in

seconds, of a write of data to the disk.

Multiplied by 1000000 to provide a useful gauge

value since it is commonly a fractional value."

::= { logicalDiskEntry 12 }

lDiskCurrentDiskQueueLength OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Current Disk Queue Length is the number of

requests outstanding on the disk at the time

the performance data is collected. It includes

requests in service at the time of the

snapshot. This is an instantaneous length, not

an average over the time interval.

Multi-spindle disk devices can have multiple

requests active at one time, but other

concurrent requests are awaiting service. This

counter might reflect a transitory high or low

queue length, but if there is a sustained load

on the disk drive, it is likely that this will

be consistently high. Requests are

experiencing delays proportional to the length

of this queue minus the number of spindles on

the disks. This difference should average less

than 2 for good performance."

::= { logicalDiskEntry 13 }

lDiskDiskBytesPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Disk Bytes/sec is the rate bytes are

transferred to or from the disk during write or

read operations."

::= { logicalDiskEntry 14 }

lDiskDiskReadBytesPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Disk Read Bytes/sec is the rate bytes are

transferred from the disk during read

operations."

::= { logicalDiskEntry 15 }

lDiskDiskReadsPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Disk Reads/sec is the rate of read operations

on the disk."

::= { logicalDiskEntry 16 }

lDiskDiskTransfersPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Disk Transfers/sec is the rate of read and

write operations on the disk."

::= { logicalDiskEntry 17 }

lDiskDiskWriteBytesPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Disk Write Bytes is rate bytes are transferred

to the disk during write operations."

::= { logicalDiskEntry 18 }

lDiskDiskWritesPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Disk Writes/sec is the rate of write

operations on the disk."

::= { logicalDiskEntry 19 }

lDiskFreeMegabytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Free Megabytes displays the unallocated space

on the disk drive in megabytes. One megabyte =

1,048,576 bytes."

::= { logicalDiskEntry 20 }

lDiskSplitIOPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Split IO/Sec reports the rate that I/Os to the

disk were split into multiple I/Os. A split

I/O may result from requesting data in a size

that is too large to fit into a single I/O or

that the disk is fragmented."

::= { logicalDiskEntry 21 }

memory OBJECT-IDENTITY

STATUS current

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

(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."

::= { standard 2 }

memoryAvailableBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Available Bytes is the amount of physical

memory available to processes running on the

computer, in bytes. It is calculated by

summing 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. "

::= { memory 1 }

memoryAvailableKBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Available KBytes is the amount of physical

memory available to processes running on the

computer, in Kilobytes (Bytes / 1,024). It is

calculated by summing 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. "

::= { memory 2 }

memoryAvailableMBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Available MBytes is the amount of physical

memory available to processes running on the

computer, in Megabytes (Bytes / 1,048,576). It

is calculated by summing 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. "

::= { memory 3 }

memoryCommittedBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Committed Bytes is the amount of committed

virtual memory, in bytes. (Committed memory is

physical memory for which space has been

reserved on the disk paging file in case it

needs to be written back to disk). This counter

displays the last observed value only; it is

not an average. "

::= { memory 4 }

memoryCacheBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Cache Bytes is the sum of the System Cache

Resident Bytes, System Driver Resident Bytes,

System Code Resident Bytes, and Pool Paged

Resident Bytes counters. This counter displays

the last observed value only; it is not an

average. "

::= { memory 5 }

memoryCacheBytesPeak OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Cache Bytes Peak is the maximum value of Cache

Bytes since the system was last restarted.

This value might be larger than the current

size of the cache. Cache Bytes is the sum of

the System Cache Resident Bytes, System Driver

Resident Bytes, System Code Resident Bytes, and

Pool Paged Resident Bytes counters. This

counter displays the last observed value only;

it is not an average. "

::= { memory 6 }

memoryPageFaultsPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Page Faults/sec is the overall rate faulted

pages are handled by the processor. It is

measured in numbers of pages faulted per

second. A page fault occurs when a process

requires code or data that is not in its

working set (its space in physical memory).

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

consequence. However, hard faults can cause

significant delays. This counter displays the

difference between the values observed in the

last two samples, divided by the duration of

the sample interval. "

::= { memory 7 }

memoryPagesInputPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Pages Input/sec is the number of pages read

from disk to resolve hard page faults. (Hard

page faults occur when a process requires code

or data that is not in its working set or

elsewhere in physical memory, and must be

retrieved from disk). This counter was designed

as a primary indicator of the kinds of faults

that cause system-wide delays. It includes

pages retrieved to satisfy faults in the file

system cache (usually requested by

applications) and in non-cached mapped memory

files. This counter counts numbers of pages,

and can be compared to other counts of pages,

such as Memory: Page Faults/sec, without

conversion. This counter displays the

difference between the values observed in the

last two samples, divided by the duration of

the sample interval. "

::= { memory 8 }

memoryPagesOutputPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Pages Output/sec is the number of pages

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 NT writes more pages back to

disk to free up space when physical memory is

in short supply. This counter counts numbers

of pages, and can be compared to other counts

of pages, without conversion. This counter

displays the difference between the values

observed in the last two samples, divided by

the duration of the sample interval. "

::= { memory 9 }

memoryPagesPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Pages/sec is the number of pages read from or

written to disk to resolve hard page faults.

(Hard page faults occur when a process requires

code or data that is not in its working set or

elsewhere in physical memory, and must be

retrieved from disk). This counter was designed

as 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. This counter displays the

difference between the values observed in the

last two samples, divided by the duration of

the sample interval. "

::= { memory 10 }

memoryPoolNonpagedBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Pool Nonpaged Bytes is the number of bytes in

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. "

::= { memory 11 }

memoryPoolPagedBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Pool Paged Bytes is the number of bytes in 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. "

::= { memory 12 }

memoryPoolPagedResidentBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Pool Paged Resident Bytes is the current size

of paged pool in bytes. 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. "

::= { memory 13 }

memorySystemCacheResidentBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Cache Resident Bytes is the number of

bytes from the file system cache that are

resident in physical memory. This value

includes only current physical pages and does

not include any virtual memory pages not

currently resident. As such 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. This counter displays the last

observed value only; it is not an average. "

::= { memory 14 }

memorySystemCodeResidentBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Code Resident Bytes is the number of

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 and cannot be written to disk.

This counter displays the last observed value

only; it is not an average. "

::= { memory 15 }

memorySystemCodeTotalBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Code Total Bytes is the number of 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 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. "

::= { memory 16 }

memorySystemDriverResidentBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Driver Resident Bytes is the number of

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 System

Driver Resident Bytes nor System Driver Total

Bytes includes memory that cannot be written to

disk."

::= { memory 17 }

memorySystemDriverTotalBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Driver Total Bytes is the number of

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

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. "

::= { memory 18 }

memoryCommittedKBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Committed KiloBytes is the amount of committed

virtual memory, in kilobytes. 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."

::= { memory 19 }

memoryCacheKBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Cache KiloBytes is the sum of the

Memory\\System Cache Resident KiloBytes,

Memory\\System Driver Resident KiloBytes,

Memory\\System Code Resident KiloBytes, and

Memory\\Pool Paged Resident KiloBytes counters.

This counter displays the last observed value

only; it is not an average. "

::= { memory 20 }

memoryCacheKBytesPeak OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Cache KiloBytes Peak is the maximum number of

kilobytes 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. "

::= { memory 21 }

memoryPoolNonpagedKBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Pool Nonpaged KiloBytes is the size, in

kilobytes, 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 KiloBytes is calculated

differently than Process\\Pool Nonpaged

KiloBytes, so it might not equal Process\\Pool

Nonpaged KiloBytes\\_Total. This counter

displays the last observed value only; it is

not an average."

::= { memory 22 }

memoryPoolPagedKBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Pool Paged KiloBytes is the size, in

kilobytes, 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 KiloBytes is calculated differently than

Process\\Pool Paged KiloBytes, so it might not

equal Process\\Pool Paged KiloBytes\\_Total.

This counter displays the last observed value

only; it is not an average."

::= { memory 23 }

memoryPoolPagedResidentKBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Pool Paged Resident KiloBytes is the current

size, in kilobytes, 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."

::= { memory 24 }

memorySystemCacheResidentKBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Cache Resident KiloBytes is the size,

in kilobytes, 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 KiloBytes 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. "

::= { memory 25 }

memorySystemCodeResidentKBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Code Resident KiloBytes is the size, in

kilobytes 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

KiloBytes, which also includes operating system

code on disk. Memory\\System Code Resident

KiloBytes (and Memory\\System Code Total

KiloBytes) 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."

::= { memory 26 }

memorySystemCodeTotalKBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Code Total KiloBytes is the size, in

kilobytes, 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 kilobytes 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."

::= { memory 27 }

memorySystemDriverResidentKBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Driver Resident KiloBytes is the size,

in kilobytes, 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 KiloBytes, which also includes driver

memory that has been written to disk. Neither

Memory\\System Driver Resident KiloBytes nor

Memory\\System Driver Total KiloBytes includes

memory that cannot be written to disk."

::= { memory 28 }

memorySystemDriverTotalKBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Driver Total KiloBytes is the size, in

kilobytes, 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 KiloBytes) and

code and data paged to disk. It is a component

of Memory\\System Code Total KiloBytes. This

counter displays the last observed value only;

it is not an average. "

::= { memory 29 }

memoryCommittedMBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Committed MegaBytes is the amount of committed

virtual memory, in megabytes. 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."

::= { memory 30 }

memoryCacheMBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Cache MegaBytes is the sum of the

Memory\\System Cache Resident MegaBytes,

Memory\\System Driver Resident MegaBytes,

Memory\\System Code Resident MegaBytes, and

Memory\\Pool Paged Resident MegaBytes counters.

This counter displays the last observed value

only; it is not an average. "

::= { memory 31 }

memoryCacheMBytesPeak OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Cache MegaBytes Peak is the maximum number of

megabytes 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. "

::= { memory 32 }

memoryPoolNonpagedMBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Pool Nonpaged MegaBytes is the size, in

megabytes, 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 MegaBytes is calculated

differently than Process\\Pool Nonpaged

MegaBytes, so it might not equal Process\\Pool

Nonpaged MegaBytes\\_Total. This counter

displays the last observed value only; it is

not an average."

::= { memory 33 }

memoryPoolPagedMBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Pool Paged MegaBytes is the size, in

megabytes, 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 MegaBytes is calculated differently than

Process\\Pool Paged MegaBytes, so it might not

equal Process\\Pool Paged MegaBytes\\_Total.

This counter displays the last observed value

only; it is not an average."

::= { memory 34 }

memoryPoolPagedResidentMBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Pool Paged Resident MegaBytes is the current

size, in megabytes, 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."

::= { memory 35 }

memorySystemCacheResidentMBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Cache Resident MegaBytes is the size,

in megabytes, 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 MegaBytes 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. "

::= { memory 36 }

memorySystemCodeResidentMBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Code Resident MegaBytes is the size, in

megabytes 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

MegaBytes, which also includes operating system

code on disk. Memory\\System Code Resident

MegaBytes (and Memory\\System Code Total

MegaBytes) 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."

::= { memory 37 }

memorySystemCodeTotalMBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Code Total MegaBytes is the size, in

megabytes, 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 megabytes 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."

::= { memory 38 }

memorySystemDriverResidentMBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Driver Resident MegaBytes is the size,

in megabytes, 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 MegaBytes, which also includes driver

memory that has been written to disk. Neither

Memory\\System Driver Resident MegaBytes nor

Memory\\System Driver Total MegaBytes includes

memory that cannot be written to disk."

::= { memory 39 }

memorySystemDriverTotalMBytes OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Driver Total MegaBytes is the size, in

megabytes, 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 MegaBytes) and

code and data paged to disk. It is a component

of Memory\\System Code Total MegaBytes. This

counter displays the last observed value only;

it is not an average. "

::= { memory 40 }

networkInterfaceTable OBJECT-TYPE

SYNTAX SEQUENCE OF NetworkInterfaceEntry

MAX-ACCESS not-accessible

STATUS current

DESCRIPTION

"The Network Interface performance object

consists of counters that measure the rates at

which bytes and packets are sent and received

over a TCP/IP connection. It includes counters

that monitor connection errors. The Network

Interface counters display data about the

network adapters on the server computer. The

first instance of the Network Interface object

(Instance 1) that you see in System Monitor

represents the loopback. The loopback is a

local path through the protocol driver and the

network adapter. All other instances represent

installed network adapters."

::= { standard 3 }

networkInterfaceEntry OBJECT-TYPE

SYNTAX NetworkInterfaceEntry

MAX-ACCESS not-accessible

STATUS current

DESCRIPTION

"Performance information for one particular

instance of 'Network Interface' object."

INDEX { netInstance }

::= { networkInterfaceTable 1 }

NetworkInterfaceEntry ::= SEQUENCE {

netInstance InstanceName,

netBytesReceivedPerSec Gauge32,

netBytesSentPerSec Gauge32,

netBytesTotalPerSec Gauge32,

netCurrentBandwidth Gauge32,

netOutputQueueLength Gauge32,

netPacketsOutboundDiscarded Gauge32,

netPacketsOutboundErrors Gauge32,

netPacketsReceivedDiscarded Gauge32,

netPacketsReceivedErrors Gauge32,

netPacketsReceivedUnknown Gauge32,

netPacketsReceivedPerSec Gauge32,

netPacketsSentPerSec Gauge32,

netPacketsPerSec Gauge32

}

netInstance OBJECT-TYPE

SYNTAX InstanceName

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Instance name."

::= { networkInterfaceEntry 1 }

netBytesReceivedPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Bytes Received/sec is the rate at which bytes

are received on the interface, including

framing characters."

::= { networkInterfaceEntry 2 }

netBytesSentPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Bytes Sent/sec is the rate at which bytes are

sent on the interface, including framing

characters."

::= { networkInterfaceEntry 3 }

netBytesTotalPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Bytes Total/sec is the rate at which bytes are

sent and received on the interface, including

framing characters."

::= { networkInterfaceEntry 4 }

netCurrentBandwidth OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Current Bandwidth is an estimate of the

interface's current bandwidth in bits per

second (BPS). For interfaces that do not vary

in bandwidth or for those where no accurate

estimation can be made, this value is the

nominal bandwidth."

::= { networkInterfaceEntry 5 }

netOutputQueueLength OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Output Queue Length is the length of the

output packet queue (in packets). If this is

longer than 2, delays are being experienced and

the bottleneck should be found and eliminated

if possible. Since the requests are queued by

NDIS in this implementation, this will always

be 0."

::= { networkInterfaceEntry 6 }

netPacketsOutboundDiscarded OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Packets Outbound Discarded is the number of

outbound packets that were chosen to be

discarded even though no errors had been

detected to prevent their being transmitted.

One possible reason for discarding such a

packet could be to free up buffer space."

::= { networkInterfaceEntry 7 }

netPacketsOutboundErrors OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Packets Outbound Errors is the number of

outbound packets that could not be transmitted

because of errors."

::= { networkInterfaceEntry 8 }

netPacketsReceivedDiscarded OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Packets Received Discarded is the number of

inbound packets that were chosen to be

discarded even though no errors had been

detected to prevent their being deliverable to

a higher-layer protocol. One possible reason

for discarding such a packet could be to free

up buffer space."

::= { networkInterfaceEntry 9 }

netPacketsReceivedErrors OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Packets Received Errors is the number of

inbound packets that contained errors

preventing them from being deliverable to a

higher-layer protocol."

::= { networkInterfaceEntry 10 }

netPacketsReceivedUnknown OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Packets Received Unknown is the number of

packets received via the interface that were

discarded because of an unknown or unsupported

protocol."

::= { networkInterfaceEntry 11 }

netPacketsReceivedPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Packets Received/sec is the rate at which

packets are received on the network interface."

::= { networkInterfaceEntry 12 }

netPacketsSentPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Packets Sent/sec is the rate at which packets

are sent on the network interface."

::= { networkInterfaceEntry 13 }

netPacketsPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Packets/sec is the rate at which packets are

sent and received on the network interface."

::= { networkInterfaceEntry 14 }

objects OBJECT-IDENTITY

STATUS current

DESCRIPTION

"The Objects performance object consists of

counters that monitor logical objects in the

system, such as processes, threads, mutexes,

and semaphores. This information can be used to

detect the unnecessary consumption of computer

resources. Each object requires memory to store

basic information about the object."

::= { standard 4 }

objectsProcesses OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Processes is the number of processes in the

computer at the time of data collection.

Notice that this is an instantaneous count, not

an average over the time interval. Each

process represents the running of a program."

::= { objects 1 }

objectsThreads OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Threads is the number of threads in the

computer at the time of data collection.

Notice that this is an instantaneous count, not

an average over the time interval. A thread is

the basic executable entity that can execute

instructions in a processor."

::= { objects 2 }

processorTable OBJECT-TYPE

SYNTAX SEQUENCE OF ProcessorEntry

MAX-ACCESS not-accessible

STATUS current

DESCRIPTION

"The Processor performance object consists of

counters that measure aspects of processor

activity. The processor is the part of the

computer that performs arithmetic and logical

computations, initiates operations on

peripherals, and runs the threads of processes.

A computer can have multiple processors. The

processor object represents each processor as

an instance of the object."

::= { standard 5 }

processorEntry OBJECT-TYPE

SYNTAX ProcessorEntry

MAX-ACCESS not-accessible

STATUS current

DESCRIPTION

"Performance information for one particular

instance of 'Processor' object."

INDEX { cpuInstance }

::= { processorTable 1 }

ProcessorEntry ::= SEQUENCE {

cpuInstance InstanceName,

cpuPercentDPCTime Gauge32,

cpuPercentInterruptTime Gauge32,

cpuPercentPrivilegedTime Gauge32,

cpuPercentProcessorTime Gauge32,

cpuPercentUserTime Gauge32,

cpuAPCBypassesPerSec Gauge32,

cpuDPCBypassesPerSec Gauge32,

cpuDPCRate Gauge32,

cpuDPCsQueuedPerSec Gauge32,

cpuInterruptsPerSec Gauge32

}

cpuInstance OBJECT-TYPE

SYNTAX InstanceName

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Instance name."

::= { processorEntry 1 }

cpuPercentDPCTime OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"% DPC Time is the percentage of time that the

processor spent receiving and servicing

deferred procedure calls (DPCs) during the

sample interval. (DPCs are interrupts that run

at a lower priority than standard interrupts).

% DPC Time is a component of % Privileged Time

because DPCs are executed in privileged mode.

They are counted separately and are not a

component of the interrupt counters. This

counter displays the average busy time as a

percentage of the sample time. "

::= { processorEntry 2 }

cpuPercentInterruptTime OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"% Interrupt Time is the percentage of time the

processor spent receiving and servicing

hardware interrupts during the sample interval.

This value is an indirect indicator of the

activity of devices that generate interrupts,

such as the system clock, the mouse, disk

drivers, data communication lines, network

interface cards and other peripheral devices.

These devices normally interrupt the processor

when they have completed a task or require

attention. Normal thread execution is

suspended during interrupts. Most system

clocks interrupt the processor every 10

milliseconds, creating a background of

interrupt activity. This counter displays the

average busy time as a percentage of the sample

time. "

::= { processorEntry 3 }

cpuPercentPrivilegedTime OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"% Privileged Time is the percentage of

non-idle processor time spent in privileged

mode. (Privileged mode is a processing mode

designed for operating system components and

hardware-manipulating drivers. It allows

direct access to hardware and all memory. The

alternative, user mode, is a restricted

processing mode designed for applications,

environment subsystems, and integral

subsystems. The operating system switches

application threads to privileged mode to

access operating system services). % Privileged

Time includes time servicing interrupts and

DPCs. A high rate of privileged time might be

attributable to a large number of interrupts

generated by a failing device. This counter

displays the average busy time as a percentage

of the sample time. "

::= { processorEntry 4 }

cpuPercentProcessorTime OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"% Processor Time is the percentage of time

that the processor is executing a non-Idle

thread. This counter was designed as a primary

indicator of processor activity. It is

calculated by measuring the time that the

processor spends executing the thread of the

Idle process in each sample interval, and

subtracting that value from 100%. (Each

processor has an Idle thread which consumes

cycles when no other threads are ready to run).

It can be viewed as the percentage of the

sample interval spent doing useful work. This

counter displays the average percentage of busy

time observed during the sample interval. It

is calculated by monitoring the time the

service was inactive, and then subtracting that

value from 100%."

::= { processorEntry 5 }

cpuPercentUserTime OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"% User Time is the percentage of non-idle

processor time spent in user mode. (User mode

is a restricted processing mode designed for

applications, environment subsystems, and

integral subsystems. The alternative,

privileged mode, is designed for operating

system components and allows direct access to

hardware and all memory. The operating system

switches application threads to privileged mode

to access operating system services). This

counter displays the average busy time as a

percentage of the sample time. "

::= { processorEntry 6 }

cpuAPCBypassesPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"APC Bypasses/sec is the rate at which Kernel

APC interrupts were avoided. APC Bypasses/sec

is the rate at which kernel APC interrupts were

short-circuited. This counter displays the

difference between the values observed in the

last two samples, divided by the duration of

the sample interval."

::= { processorEntry 7 }

cpuDPCBypassesPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"DPC Bypasses/sec is the rate at which deferred

procedure calls (DPCs) on all processors were

avoided. (DPCs are interrupts that run at a

lower priority than standard interrupts). This

counter displays the difference between the

values observed in the last two samples,

divided by the duration of the sample

interval."

::= { processorEntry 8 }

cpuDPCRate OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"DPC Rate is the rate at which deferred

procedure calls (DPCs) are added to the

processor's DPC queue between the timer ticks

of the processor clock. (DPCs are interrupts

that run at a lower priority than standard

interrupts. Each processor has its own DPC

queue). This counter measures the rate at which

DPCs are added to the queue, not the number of

DPCs in the queue. This counter displays the

last observed value only; it is not an average.

::= { processorEntry 9 }

cpuDPCsQueuedPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"DPCs Queued/sec is the overall rate at which

deferred procedure calls (DPCs) are added to

the processor's DPC queue. (DPCs are

interrupts that run at a lower priority than

standard interrupts. Each processor has its

own DPC queue). This counter measures the rate

at which DPCs are added to the queue, not the

number of DPCs in the queue. This counter

displays the difference between the values

observed in the last two samples, divided by

the duration of the sample interval. "

::= { processorEntry 10 }

cpuInterruptsPerSec OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"Interrupts/sec is the average number of

hardware interrupts the processor is receiving

and servicing in each second. It does not

include DPCs, which are counted separately.

This value is an indirect indicator of the

activity of devices that generate interrupts,

such as the system clock, the mouse, disk

drivers, data communication lines, network

interface cards and other peripheral devices.

These devices normally interrupt the processor

when they have completed a task or require

attention. Normal thread execution is suspended

during interrupts. Most system clocks interrupt

the processor every 10 milliseconds, creating a

background of interrupt activity. This counter

displays the difference between the values

observed in the last two samples, divided by

the duration of the sample interval. "

::= { processorEntry 11 }

system OBJECT-IDENTITY

STATUS current

DESCRIPTION

"The System performance object consists of

counters that apply to more than one component

of the computer. Percentage counters by default

do not show values above 100 percent. See

'Overview of Performance Monitoring' in the

Windows 2000 Server Resource Kit Server

Operations Guide for instructions about

changing this default in the registry."

::= { standard 6 }

systemSystemUpTime OBJECT-TYPE

SYNTAX Gauge32

MAX-ACCESS read-only

STATUS current

DESCRIPTION

"System Up Time is the elapsed time (in

seconds) that the computer has been running

since it was last started. This counter

displays the difference between the start time

and the current time. "

::= { system 1 }

END

RootLinks Co., Ltd.

snmp informant

Leave a Reply Cancel Reply

2012年10月
日	月	火	水	木	金	土
	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30	31

RootLinks Co., Ltd.

snmp informant

Related posts:

Leave a Reply Cancel Reply