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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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
|
@ hotproc.cpuburn CPU utilization per "interesting" process
CPU utilization, or the fraction of time that each "interesting" process
was executing (user and system time) over the last refresh interval.
Also known as the "cpuburn" time.
@ hotproc.control.refresh time in secs between refreshes
Controls how long it takes before the "interesting" process list is refreshed
and new cpuburn times (see hotproc.cpuburn) calculated. This value can be
changed at any time by using pmstore(1) if the permission is given during
installation of the hotproc PMDA. Once the value is changed, the instances
will not be available until after the new refresh period has elapsed.
@ hotproc.control.config configuration predicate
The configuration predicate that is used to characterize "interesting"
processes. This will initially be the predicate as specified in the
configuration file. This value can be changed at any time by using
pmstore(1) if the permission is given during installation of the hotproc
PMDA. Once the value is changed, the instances will not be available
until after the refresh period has elapsed.
@ hotproc.control.config_gen configuration generation number
Each time the configuration predicate is updated (see hotproc.control.config)
the configuration generation number is incremented.
@ hotproc.total.cpuburn total amount of cpuburn over all "interesting" processes
The sum of the CPU utilization ("cpuburn" or the fraction of time that each
process was executing in user or system mode over the last refresh interval)
for all the "interesting" processes.
Values are in the range 0 to the number of CPUs.
@ hotproc.total.cpuidle fraction of CPU idle time
The fraction of all CPU time classified as idle over the last refresh
interval.
@ hotproc.total.cpuother.not_cpuburn total amount of cpuburn over all uninteresting processes
The sum of the CPU utilization ("cpuburn" or the fraction of time that
each process was executing in user or system mode over the last refresh
interval) for all the "uninteresting" processes. If this value is high in
comparison to hotproc.total.cpuburn, then configuration predicate of the
hotproc PMDA is classifying a significant fraction of the CPU utilization
to processes that are not "interesting".
Values are in the range 0 to the number of CPUs.
@ hotproc.total.cpuother.transient fraction of time utilized by "transient" processes
The total CPU utilization (fraction of time that each process was executing
in user or system mode) for processes which are not present throughout
the most recent refreshes interval. The hotproc PMDA is limited to
selecting processes which are present throughout each refresh intervals.
If processes come and/or go during a refresh interval then they will never
be considered. This metric gives an indication of the level of activity of
these "transient" processes. If the value is large in comparison to the
sum of hotproc.total.cpuburn and hotproc.total.cpuother.not_cpuburn then
the "transient" processes are consuming lots of CPU time. Under these
circumstances, the hotproc PMDA may be less useful, or consideration
should be given to decreasing the value of the refresh interval
(hotproc.control.refresh) so fewer "transient" processes escape
consideration.
Values are in the range 0 to the number of CPUs.
@ hotproc.total.cpuother.total total amount of cpuburn other than the "interesting" processes
Non-idle CPU utilization not accounted for by processes other than those
deemed "interesting". It is equivalent to hotproc.total.cpuother.not_cpuburn
+ hotproc.total.cpuother.transient.
Values are in the range 0 to the number of CPUs.
@ hotproc.total.cpuother.percent how much of the cpu for "transients" and uninterestings
Gives an indication of how much of the CPU time the "transient" processes
and the "uninteresting" processes are accounting for. Computed as:
100 * hotproc.total.cpuother.total / number of CPUs
@ hotproc.predicate.syscalls number of system calls per second over refresh interval
The number of system calls per second over the last refresh interval for
each "interesting" process. If the refresh interval spans times from t1
to t2, then this is calculated by:
m = hotproc.psusage.pu_sysc
(m@t2 - m@t1) / (t2 - t1)
@ hotproc.predicate.ctxswitch number of context switches per second over refresh interval
The number of context switches per second over the last refresh interval
for each "interesting" process. If the refresh interval spans times from
t1 to t2, then this is calculated by:
m = hotproc.psusage.pu_vctx + hotproc.psusage.pu_ictx
(m@t2 - m@t1) / (t2 - t1)
@ hotproc.predicate.virtualsize virtual size of process in kilobytes at last refresh
The virtual size of each "interesting" process in kilobytes at the last
refresh time, calculated by:
hotproc.psinfo.size
@ hotproc.predicate.residentsize resident size of process in kilobytes at last refresh
The resident size of each "interesting" process in kilobytes at the last
refresh, calculated by:
hotproc.psinfo.rssize
@ hotproc.predicate.iodemand total kilobytes read and written per second over refresh interval
The total kilobytes read and written per second over the last refresh
interval for each "interesting" process. If the refresh interval spans
times from t1 to t2, then this is calculated by:
// bytes read()
br = hotproc.psusage.bread@t2 - hotproc.psusage.bread@t1
// Gigabytes read()
gbr = hotproc.psusage.gbread@t2 - hotproc.psusage.gbread@t1
// bytes write()
bw = hotproc.psusage.bwrit@t2 - hotproc.psusage.bwrit@t1
// Gigabytes write()
gbw = hotproc.psusage.gbwrit@t2 - hotproc.psusage.gbwrit@t1
((gbr + gbw) * 1024 * 1024 + (br + bw) / 1024 ) / (t2 - t1)
@ hotproc.predicate.iowait time in secs waiting for I/O per second over refresh interval
The fraction of time waiting for I/O for each "interesting" process over
refresh interval. If the refresh interval spans times from t1 to t2,
then this is calculated by:
bw = (hotproc.accounting.timers.bwtime@t2 -
hotproc.accounting.timers.bwtime@t1) / 1000000000
rw = (hotproc.accounting.timers.rwtime@t2 -
hotproc.accounting.timers.rwtime@t1) / 1000000000
(bw + rw) / (t2 - t1)
@ hotproc.predicate.schedwait time in secs waiting on run queue per second over refresh interval
The fraction of time waiting on the run queue for each "interesting"
process over the last refresh interval. If the refresh interval spans
times from t1 to t2, then this is calculated by:
qw = (hotproc.accounting.timers.qwtime@t2 -
hotproc.accounting.timers.qwtime@t1) / 1000000000
qw / (t2 - t1)
|
