@ 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)