diff options
Diffstat (limited to 'src/pmdas/hotproc/help.hotproc')
| -rw-r--r-- | src/pmdas/hotproc/help.hotproc | 141 |
1 files changed, 141 insertions, 0 deletions
diff --git a/src/pmdas/hotproc/help.hotproc b/src/pmdas/hotproc/help.hotproc new file mode 100644 index 0000000..30a74da --- /dev/null +++ b/src/pmdas/hotproc/help.hotproc @@ -0,0 +1,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) |