 |
HP OpenVMS System Management Utilities Reference
Manual
H.4.2.8 LOCK Class Record
The LOCK class record contains data describing the operation of the
lock management subsystem. The LOCK class record has a record type of 7
and a size of 53 bytes.
Figure H-19 illustrates the format of the LOCK class record.
Figure H-19 LOCK Class Record Format
The following table describes the fields in the data block for the LOCK
class record:
| Field |
Symbolic Offset |
Contents |
|
New ENQs
|
MNR_LCK$L_ENQNEW
|
Count of new ENQ (lock) requests (longword,C)
|
|
Converted ENQs
|
MNR_LCK$L_ENQCVT
|
Count of converted ENQ (lock) requests (longword,C)
|
|
DEQs
|
MNR_LCK$L_DEQ
|
Count of DEQ (unlock) requests (longword,C)
|
|
Blocking ASTs
|
MNR_LCK$L_BLKAST
|
Count of blocking ASTs queued (longword,C)
|
|
ENQ Waits
|
MNR_LCK$L_ENQWAIT
|
Count of times a lock could not be granted immediately and waited
(longword,C)
|
|
ENQs Not Queued
|
MNR_LCK$L_ENQNOTQD
|
Count of times a lock could not be granted immediately and got an error
status instead of waiting (longword,C)
|
|
Deadlock Searches
|
MNR_LCK$L_DLCKSRCH
|
Count of times that a deadlock search was performed (longword,C)
|
|
Deadlocks Found
|
MNR_LCK$L_DLCKFND
|
Count of times that a deadlock was found (longword,C)
|
|
Current Locks
|
MNR_LCK$L_NUMLOCKS
|
Number of locks currently in the system (longword,L)
|
|
Current Resources
|
MNR_LCK$L_NUMRES
|
Number of resources currently in the system (longword,L)
|
H.4.2.9 MODES Class Record
The MODES class record contains data describing time spent in each of
the processor modes. The MODES class record has a record type of 2; its
size depends on the number of active CPUs on the system being
monitored. The size, in bytes, is calculated by adding the size of the
class header, the class prefix, and the data blocks contained in the
record. This is shown in the following formula, which assumes that all
CPUs are active:
13 + 8 + (33 * MNR_SYI$B_MPCPUS)
|
Figure H-20 illustrates the format of the MODES class record.
Figure H-20 MODES Class Record Format
The following table describes the fields in the data block for the
MODES class record:
| Field |
Symbolic Offset |
Contents |
|
CPU ID
|
MNR_MOD$L_CPUID
MNR_MOD$B_CPUID (VAX)
|
CPU identification (longword,I)
|
|
Interrupt Stack
|
MNR_MOD$L_INTER
|
Count of clock ticks (10-millisecond units) spent on interrupt stack
since system was booted (longword,C)
|
|
MP Synchronization
|
MNR_MOD$L_MPSYNC
|
Count of clock ticks spent synchronizing multiple CPUs since system boot
|
|
Kernel
|
MNR_MOD$L_KERNEL
|
Count of clock ticks spent in kernel mode, excluding interrupt stack
time, since system boot (longword,C)
|
|
Executive
|
MNR_MOD$L_EXEC
|
Count of clock ticks spent in executive mode since system boot
(longword,C)
|
|
Supervisor
|
MNR_MOD$L_SUPER
|
Count of clock ticks spent in supervisor mode since system boot
(longword,C)
|
|
User
|
MNR_MOD$L_USER
|
Count of clock ticks spent in user mode, excluding compatibility mode
time since system boot (longword,C)
|
|
Compatibility
|
MNR_MOD$L_COMPAT
|
Count of clock ticks boot spent in compatibility mode since system boot
(longword,C)
|
|
Idle
|
MNR_MOD$L_IDLE
|
Count of clock ticks spent executing the NULL process since system boot
(longword,C)
|
H.4.2.10 MSCP_SERVER Class Record
The MSCP_SERVER class record contains data describing activities of the
MSCP server. The MSCP_SERVER class record has a record type of 21 and a
size of 65 bytes.
Figure H-21 illustrates the format of the MSCP_SERVER class record.
Figure H-21 MSCP_SERVER Class Record Format
The following table describes the fields in the data block for the
MSCP_SERVER class record:
| Field |
Symbolic Offset |
Contents |
|
Requests
|
MNR_MSC$L_REQUEST
|
Count of requests for I/O transfers by remote processors (longword,C)
|
|
Reads
|
MNR_MSC$L_READ
|
Count of requests for Read I/O transfers by remote processors
(longword,C)
|
|
Writes
|
MNR_MSC$L_WRITE
|
Count of requests for Write I/O transfers by remote processors
(longword,C)
|
|
Fragments
|
MNR_MSC$L_FRAGMENT
|
Count of extra fragments issued by the server (longword,C)
|
|
Splits
|
MNR_MSC$L_SPLIT
|
Count of fragmented requests issued by the server (longword,C)
|
|
Buffer Waits
|
MNR_MSC$L_BUFWAIT
|
Count of requests that had to wait for MSCP buffer memory (longword,C)
|
|
1 Block I/Os
|
MNR_MSC$L_SIZE1
|
Count of I/O requests with a length of one block (longword,C)
|
|
2---3 Block I/Os
|
MNR_MSC$L_SIZE2
|
Count of I/O requests with a length of 2 to 3 blocks (longword,C)
|
|
4---7 Block I/Os
|
MNR_MSC$L_SIZE3
|
Count of I/O requests with a length of 4 to 7 blocks (longword,C)
|
|
8---15 Block I/Os
|
MNR_MSC$L_SIZE4
|
Count of I/O requests with a length of 8 to 15 blocks (longword,C)
|
|
16---31 Block I/Os
|
MNR_MSC$L_SIZE5
|
Count of I/O requests with a length of 16 to 31 blocks (longword,C)
|
|
32---63 Block I/Os
|
MNR_MSC$L_SIZE6
|
Count of I/O requests with a length of 32 to 63 blocks (longword,C)
|
|
64+ Block I/Os
|
MNR_MSC$L_SIZE7
|
Count of I/O requests with a length equal to or greater than 64 blocks
(longword,C)
|
H.4.2.11 PAGE Class Record
The PAGE class record contains data describing the operation of the
page management subsystem. The PAGE class record has a record type of 3
and a size of 65 bytes.
Figure H-22 illustrates the format of the PAGE class record.
Figure H-22 PAGE Class Record Format
The following table describes the fields in the data block for the PAGE
class record:
| Field |
Symbolic Offset |
Contents |
|
Page Faults
|
MNR_PAG$L_FAULTS
|
Count of page faults for all working set (longword,C)
|
|
Reads
|
MNR_PAG$L_PREADS
|
Count of pages read from disk as a result of page faults (longword,C)
|
|
Read I/Os
|
MNR_PAG$L_PREADIO
|
Count of read I/Os as a result of operations from disk page faults
(longword,C)
|
|
Writes
|
MNR_PAG$L_PWRITES
|
Count of pages written to the page file (longword,C)
|
|
Write I/Os
|
MNR_PAG$L_PWRITIO
|
Count of write I/O operations to the page file (longword,C)
|
Free-page
List Faults
|
MNR_PAG$L_FREFLTS
|
Count of pages read from the free list as a result of page faults
(longword,C)
|
Modified-page
List Faults
|
MNR_PAG$L_MFYFLTS
|
Count of pages read from the modified list as a result of page faults
(longword,C)
|
Demand-zero
Faults
|
MNR_PAG$L_DZROFLTS
|
Count of zero-filled pages allocated as a result of faults (longword,C)
|
Global Valid
Faults
|
MNR_PAG$L_GVALID
|
Count of page faults for which the reference page was found to be valid
in the system global page tables (longword,C)
|
Write-in-Progress
Faults
|
MNR_PAG$L_WRTINPROG
|
Count of pages read that were in the process of being written back to
disk when faulted (longword,C)
|
|
System Faults
|
MNR_PAG$L_SYSFAULTS
|
Count of page faults for which the referenced page is in system space
(longword,C)
|
|
Free-page Count
|
MNR_PAG$L_FREECNT
|
Number of pages currently on free-page list (longword,L)
|
Modified-page
Count
|
MNR_PAG$L_MFYCNT
|
Number of pages currently on modified-page list (longword,L)
|
H.4.2.12 PROCESSES Class Record
The PROCESSES class record contains data describing all processes in
the system. The PROCESSES class record has a record type of 0; its size
depends on the number of processes being monitored. The size, in bytes,
is calculated by adding the size of the class header, the class prefix,
and the data blocks contained in the record. This is shown in the
following formula:
13 + 8 + (67 * the value of MNR_CMP$L_ELTCT)
|
Figure H-23 illustrates the format of the PROCESSES class record on
Alpha and I64 systems.
Figure H-23 PROCESSES Class Record Format - Alpha and
I64
Figure H-24 illustrates the format of the PROCESSES class record on
VAX systems.
Figure H-24 PROCESSES Class Record Format - VAX Only
The following table describes the fields in the data block for the
PROCESSES class record:
| Field |
Symbolic Offset |
Contents |
|
Internal Process ID
|
MNR_PRO$L_IPID
|
Internal process identification (longword,I)
|
|
UIC
|
MNR_PRO$L_UIC
|
User identification code (Group is high-order word; Member is low-order
word) (longword,I)
|
|
State
|
MNR_PRO$W_STATE
|
Current scheduling state code (word,I)
|
|
Priority
|
MNR_PRO$B_PRI
|
Current software priority (complement of 31) (byte,I)
|
|
Name
|
MNR_PRO$T_LNAME
|
Process name (counted ASCII string) (16 bytes,I)
|
|
Global Page Count
|
MNR_PRO$L_GPGCNT
|
Current global page count (longword,L)
|
|
Process Page Count
|
MNR_PRO$L_PPGCNT
|
Current process page count (longword,L)
|
|
Status Flags
|
MNR_PRO$L_STS
|
Software process status flags (PCB$V_RES bit clear implies swapped out)
(longword,I)
|
|
Direct I/Os
|
MNR_PRO$L_DIOCNT
|
Direct I/O count (0 if swapped out) (longword,C)
|
|
Page Faults
|
MNR_PRO$L_PAGEFLTS
|
Page fault count (0 if swapped out) (longword,C)
|
|
CPU Time
|
MNR_PRO$L_CPUTIM
|
Accumulated CPU time, in 10 ms ticks (0 if swapped out) (longword,C)
|
|
Buffered I/Os
|
MNR_PRO$L_BIOCNT
|
Buffered I/O count (0 if swapped out) (longword,C)
|
|
Extended Process ID
|
MNR_PRO$L_EPID
|
Extended process identification (longword,I)
|
|
Event Flag Weight Mask
|
MNR_PRO$L_EFWM
|
Event flag wait mask (used for MWAITs) (longword, I)
|
|
RBS Transitions
|
MNR_PRO$L_RBSTRAN
|
Real balance slot transitions (longword, C)
|
H.4.2.13 RLOCK Class Record
The RLOCK class record contains data that is useful for monitoring the
dynamic lock remastering statistics of a node. The RLOCK class record
has a record type of 27 and a size of 41 bytes.
Figure H-25 illustrates the format of the RLOCK class record.
Figure H-25 RLOCK Class Record Format
The following table describes the fields in the data block for the
RLOCK class record:
| Field |
Symbolic Offset |
Contents |
|
Lock Tree Outbound
|
MNR_RLO$L_RM_UNLOAD
|
Count of lock trees that are moved from this node.
|
|
Lock Tree-Higher Activity
|
MNR_RLO$L_RM_MORE_ACT
|
Count of trees that are moved due to higher locking activity on another
node in the cluster.
|
|
Lock Tree-Higher LCKDIRWT
|
MNR_RLO$L_RM_BETTER
|
Count of trees that are moved to a node with a higher value of the
system parameter LCKDIRWT.
|
|
Sole Interest
|
MNR_RLO$L_RM_SINGLE
|
Count of trees that are moved to another node because that node is the
only one with locks remaining on the tree.
|
|
Remaster Msg Sent
|
MNR_RLO$L_RM_MSG_SENT
|
Count of remaster messages sent from this node.
|
|
Lock Tree Inbound
|
MNR_RLO$L_RM_ACQUIRE
|
Count of trees that are moved to this node.
|
|
Remaster Msg Received
|
MNR_RLO$L_RM_MSG_RCV
|
Count of remaster messages received on this node.
|
H.4.2.14 RMS Class Record
The RMS class record contains data describing Record Management
Services for specified files. The RMS class record has a record type of
20. Use the following formula to calculate the record size (the formula
calculates the size by adding the size of the class header, the class
prefix, and the data blocks contained in the record):
13 + 8 + (273 * MNR_CMP$L_ELTCT)
|
Figure H-26 illustrates the format of the RMS class record.
Figure H-26 RMS Class Record Format
The following table describes the fields in the data block for the RMS
class record:
| Field |
Symbolic Offset |
Contents |
|
File Number (Num)
|
MNR_RMS$L_FILNUM
MNR_RMS$B_FILNUM (VAX)
|
Sequential number of the file (byte,I)
|
|
File Organization
|
MNR_RMS$L_ORG
|
Organization of the file (longword,I)
|
|
Reserved
|
MNR_RMS$L_RESERVED1
|
Reserved (longword)
|
|
Sequential GETs
|
MNR_RMS$L_SEQGETS
|
Count of sequential $GETs to the file (longword,C)
|
H.4.2.15 SCS Class Record
The SCS class record contains data describing SCS (System
Communications Services) activity for all SCS connections in the
system, on a per-node basis. The SCS class record has a record type of
15; its size depends on the number of nodes being monitored. The size,
in bytes, is calculated by adding the size of the class header, the
class prefix, and the data blocks contained in the record. This is
shown in the following formula:
13 + 8 + (56 * the value of MNR_CMP$L_ELTCT)
|
Figure H-27 illustrates the format of the SCS class record.
Figure H-27 SCS Class Record Format
The following table describes the fields in the data block for the SCS
class record:
| Field |
Symbolic Offset |
Contents |
|
Node Name
|
MNR_SCS$T_NODENAME
|
Name of remote cluster node (counted ASCII string) (8 bytes,I)
|
|
Datagrams Sent
|
MNR_SCS$L_DGSENT
|
Count of datagrams sent to the remote node (longword,C)
|
|
Datagrams Received
|
MNR_SCS$L_DGRCVD
|
Count of datagrams received from the remote node (longword,C)
|
|
Datagrams Discarded
|
MNR_SCS$L_DGDISCARD
|
Count of datagrams discarded by the CI port driver (longword,C)
|
|
Sequenced Messages Sent
|
MNR_SCS$L_MSGSENT
|
Count of sequenced messages sent to the remode node (longword,C)
|
|
Seqenced Messages Received
|
MNR_SCS$L_MSGRCVD
|
Count of sequenced messages received from the remote node (longword,C)
|
Block Transfer
Send-data commands
|
MNR_SCS$L_SNDATS
|
Count of block transfer send-data commands initiated on the local node,
targeted for the remote node (longword,C)
|
Kilobytes Sent by
Send-data commands
|
MNR_SCS$L_KBYTSENT
|
Count of kilobytes sent as a result of send-data commands (longword,C)
|
Block Transfer Request-
data commands
|
MNR_SCS$L_REQDATS
|
Count of block transfer request-data commands initiated on the local
node, targeted for the remote node (longword,C)
|
Kilobytes Received by
Request-data commands
|
MNR_SCS$L_KBYTREQD
|
Count of kilobytes received as a result of request-data commands
(longword,C)
|
Block Transfer
Kilobytes Mapped
|
MNR_SCS$L_KBYTMAPD
|
Count of kilobytes mapped for block transfers (longword,C)
|
Connections Queued For
Send Credit
|
MNR_SCS$L_QCRCNT
|
Count of times connections are queued for send credits (longword,C)
|
Connections Queued For
Buffer Descriptor
|
MNR_SCS$L_QBDTCNT
|
Count of times connections are queued for buffer descriptors
(longword,C)
|
|
