char netcpu_pstatnew_id[]="\
@(#)netcpu_pstatnew.c (c) Copyright 2005-2012 Hewlett-Packard Company, Version 2.6.0";
/* since we "know" that this interface is available only on 11.23 and
later, and that 11.23 and later are strictly 64-bit kernels, we can
arbitrarily set _PSTAT64 here and not have to worry about it up in
the configure script and makefiles. raj 2005/09/06 */
#if HAVE_CONFIG_H
# include <config.h>
#endif
#include <stdio.h>
#if HAVE_INTTYPES_H
# include <inttypes.h>
#else
# if HAVE_STDINT_H
# include <stdint.h>
# endif
#endif
#include <unistd.h>
#if HAVE_LIMITS_H
# include <limits.h>
#endif
#include <sys/dk.h>
#include <sys/pstat.h>
/* HP-UX 11.23 seems to have added three other cycle counters to the
original psp_idlecycles - one for user, one for kernel and one for
interrupt. so, we can now use those to calculate CPU utilization
without requiring any calibration phase. raj 2005-02-16 */
#ifndef PSTAT_IPCINFO
# error Sorry, pstat() CPU utilization on 10.0 and later only
#endif
typedef struct cpu_time_counters {
uint64_t idle;
uint64_t user;
uint64_t kernel;
uint64_t interrupt;
} cpu_time_counters_t;
uint64_t lib_iticksperclktick;
#include "netsh.h"
#include "netlib.h"
/* the lib_start_count and lib_end_count arrays hold the starting
and ending values of whatever is counting when the system is
idle. The rate at which this increments during a test is compared
with a previous calibrarion to arrive at a CPU utilization
percentage. raj 2005-01-26 */
static cpu_time_counters_t starting_cpu_counters[MAXCPUS];
static cpu_time_counters_t ending_cpu_counters[MAXCPUS];
static cpu_time_counters_t delta_cpu_counters[MAXCPUS];
/* there can be more "processors" in the system than are actually
online. so, we can either walk all the processors one at a time,
which would be slow, or we can track not just lib_num_loc_cpu,
which is the number of active "processors" but also the total
number, and retrieve all of them at one shot and walk the list
once, ignoring those that are offline. we will ass-u-me there is
no change to the number of processors online while we are running
or there will be strange things happening to CPU utilization. raj
2010-04-27 */
static long max_proc_count;
void
cpu_util_init(void)
{
struct pst_dynamic psd;
if (pstat_getdynamic((struct pst_dynamic *)&psd,
(size_t)sizeof(psd), (size_t)1, 0) != -1) {
max_proc_count = psd.psd_max_proc_cnt;
}
else {
/* we hope this never happens */
max_proc_count = lib_num_loc_cpus;
}
return;
}
void
cpu_util_terminate(void)
{
return;
}
int
get_cpu_method(void)
{
return HP_IDLE_COUNTER;
}
void
get_cpu_counters(cpu_time_counters_t *res)
{
/* get the idle sycle counter for each processor. now while on a
64-bit kernel the ".psc_hi" and ".psc_lo" fields are 64 bits,
only the bottom 32-bits are actually valid. don't ask me
why, that is just the way it is. soo, we shift the psc_hi
value by 32 bits and then just sum-in the psc_lo value. raj
2005/09/06 */
struct pst_processor *psp;
/* to handle the cases of "processors" present but disabled, we
will have to allocate a buffer big enough for everyone and
then walk the entire list, pulling data for those which are
online, assuming the processors online have not changed in
the middle of the run. raj 2010-04-27 */
psp = (struct pst_processor *)malloc(max_proc_count * sizeof(*psp));
if (psp == NULL) {
printf("malloc(%d) failed!\n", max_proc_count * sizeof(*psp));
exit(1);
}
if (pstat_getprocessor(psp, sizeof(*psp), max_proc_count, 0) != -1) {
int i,j;
/* we use lib_iticksperclktick in our sanity checking. we
ass-u-me it is the same value for each CPU - famous last
words no doubt. raj 2005/09/06 */
lib_iticksperclktick = psp[0].psp_iticksperclktick;
i = j = 0;
while ((i < lib_num_loc_cpus) && (j < max_proc_count)) {
if (psp[j].psp_processor_state == PSP_SPU_DISABLED) {
j++;
continue;
}
/* we know that psp[j] is online */
res[i].idle = (((uint64_t)psp[j].psp_idlecycles.psc_hi << 32) +
psp[j].psp_idlecycles.psc_lo);
if(debug) {
fprintf(where,
"\tidle[%d] = 0x%"PRIx64" ",
i,
res[i].idle);
fflush(where);
}
res[i].user = (((uint64_t)psp[j].psp_usercycles.psc_hi << 32) +
psp[j].psp_usercycles.psc_lo);
if(debug) {
fprintf(where,
"user[%d] = 0x%"PRIx64" ",
i,
res[i].user);
fflush(where);
}
res[i].kernel = (((uint64_t)psp[j].psp_systemcycles.psc_hi << 32) +
psp[j].psp_systemcycles.psc_lo);
if(debug) {
fprintf(where,
"kern[%d] = 0x%"PRIx64" ",
i,
res[i].kernel);
fflush(where);
}
res[i].interrupt = (((uint64_t)psp[j].psp_interruptcycles.psc_hi << 32) +
psp[j].psp_interruptcycles.psc_lo);
if(debug) {
fprintf(where,
"intr[%d] = 0x%"PRIx64"\n",
i,
res[i].interrupt);
fflush(where);
}
i++;
j++;
}
free(psp);
}
}
/* calibrate_pstatnew
there really isn't anything much to do here since we have all the
counters and use their ratios for CPU util measurement. raj
2005-02-16 */
float
calibrate_idle_rate(int iterations, int interval)
{
return 0.0;
}
static void
print_cpu_time_counters(char *name, int instance, cpu_time_counters_t *counters)
{
fprintf(where,
"%s[%d]:\n"
"\t idle %llu\n"
"\t user %llu\n"
"\t kernel %llu\n"
"\t interrupt %llu\n",
name,instance,
counters[instance].idle,
counters[instance].user,
counters[instance].kernel,
counters[instance].interrupt);
}
float
calc_cpu_util_internal(float elapsed_time)
{
int i;
uint64_t total_cpu_cycles;
uint64_t sanity_cpu_cycles;
#ifndef USE_INTEGER_MATH
double fraction_idle;
double fraction_user;
double fraction_kernel;
double fraction_interrupt;
double estimated_fraction_interrupt;
#else
uint64_t fraction_idle;
uint64_t fraction_user;
uint64_t fraction_kernel;
uint64_t fraction_interrupt;
uint64_t estimated_fraction_interrupt;
#define CALC_PERCENT 100
#define CALC_TENTH_PERCENT 1000
#define CALC_HUNDREDTH_PERCENT 10000
#define CALC_THOUSANDTH_PERCENT 100000
#define CALC_ACCURACY CALC_THOUSANDTH_PERCENT
#endif /* USE_INTEGER_MATH */
float actual_rate;
float correction_factor;
memset(&lib_local_cpu_stats, 0, sizeof(lib_local_cpu_stats));
/* It is possible that the library measured a time other than */
/* the one that the user want for the cpu utilization */
/* calculations - for example, tests that were ended by */
/* watchdog timers such as the udp stream test. We let these */
/* tests tell up what the elapsed time should be. */
if (elapsed_time != 0.0) {
correction_factor = (float) 1.0 +
((lib_elapsed - elapsed_time) / elapsed_time);
}
else {
correction_factor = (float) 1.0;
}
/* calculate our sanity check on cycles */
if (debug) {
fprintf(where,
"lib_elapsed %g _SC_CLK_TCK %d lib_iticksperclktick %"PRIu64"\n",
lib_elapsed,
sysconf(_SC_CLK_TCK),
lib_iticksperclktick);
}
/* Ok, elsewhere I may have said that HP-UX 11.23 does the "right"
thing in measuring user, kernel, interrupt and idle all together
instead of overlapping interrupt with the others like an OS that
shall not be named. However.... it seems there is a bug in the
accounting for interrupt cycles, whereby the cycles do not get
properly accounted. The sum of user, kernel, interrupt and idle
does not equal the clock rate multiplied by the elapsed time.
Some cycles go missing.
Since we see agreement between netperf and glance/vsar with the
old "pstat" mechanism, we can presume that the accounting for
idle cycles is sufficiently accurate. So, while we will still do
math with user, kernel and interrupt cycles, we will only
caculate CPU utilization based on the ratio of idle to _real_
total cycles. I am told that a "future release" of HP-UX will
fix the interupt cycle accounting. raj 2005/09/14 */
/* calculate what the sum of CPU cycles _SHOULD_ be */
sanity_cpu_cycles = (uint64_t) ((double)lib_elapsed *
(double) sysconf(_SC_CLK_TCK) * (double)lib_iticksperclktick);
/* this looks just like the looper case. at least I think it */
/* should :) raj 4/95 */
for (i = 0; i < lib_num_loc_cpus; i++) {
/* we ass-u-me that these counters will never wrap during a
netperf run. this may not be a particularly safe thing to
do. raj 2005-01-28 */
delta_cpu_counters[i].idle = ending_cpu_counters[i].idle -
starting_cpu_counters[i].idle;
delta_cpu_counters[i].user = ending_cpu_counters[i].user -
starting_cpu_counters[i].user;
delta_cpu_counters[i].kernel = ending_cpu_counters[i].kernel -
starting_cpu_counters[i].kernel;
delta_cpu_counters[i].interrupt = ending_cpu_counters[i].interrupt -
starting_cpu_counters[i].interrupt;
if (debug) {
print_cpu_time_counters("delta_cpu_counters",i,delta_cpu_counters);
}
/* now get the sum, which we ass-u-me does not overflow a 64-bit
counter. raj 2005-02-16 */
total_cpu_cycles =
delta_cpu_counters[i].idle +
delta_cpu_counters[i].user +
delta_cpu_counters[i].kernel +
delta_cpu_counters[i].interrupt;
if (debug) {
fprintf(where,
"total_cpu_cycles %"PRIu64" sanity_cpu_cycles %"PRIu64
" missing %"PRIu64"\n",
total_cpu_cycles,
sanity_cpu_cycles,
sanity_cpu_cycles - total_cpu_cycles);
}
/* since HP-UX 11.23 does the _RIGHT_ thing and idle/user/kernel
does _NOT_ overlap with interrupt, we do not have to apply any
correction kludge. raj 2005-02-16 */
#ifndef USE_INTEGER_MATH
/* when the accounting for interrupt time gets its act together,
we can use total_cpu_cycles rather than sanity_cpu_cycles, but
until then, use sanity_cpu_ccles. raj 2005/09/14 */
fraction_idle = (double)delta_cpu_counters[i].idle /
(double)sanity_cpu_cycles;
fraction_user = (double)delta_cpu_counters[i].user /
(double)sanity_cpu_cycles;
fraction_kernel = (double) delta_cpu_counters[i].kernel /
(double)sanity_cpu_cycles;
fraction_interrupt = (double)delta_cpu_counters[i].interrupt /
(double)sanity_cpu_cycles;
/* ass-u-me that it is only interrupt that is bogus, and assign
all the "missing" cycles to it. raj 2005/09/14 */
estimated_fraction_interrupt = ((double)delta_cpu_counters[i].interrupt +
(sanity_cpu_cycles - total_cpu_cycles)) /
(double)sanity_cpu_cycles;
if (debug) {
fprintf(where,
"\tfraction_idle %g\n"
"\tfraction_user %g\n"
"\tfraction_kernel %g\n"
"\tfraction_interrupt %g WARNING, possibly under-counted!\n"
"\testimated_fraction_interrupt %g\n",
fraction_idle,
fraction_user,
fraction_kernel,
fraction_interrupt,
estimated_fraction_interrupt);
}
/* and finally, what is our CPU utilization? */
lib_local_per_cpu_util[i] = 100.0 - (fraction_idle * 100.0);
#else
/* and now some fun with integer math. i initially tried to
promote things to long doubled but that didn't seem to result
in happiness and joy. raj 2005-01-28 */
/* multiply by 100 and divide by total and you get whole
percentages. multiply by 1000 and divide by total and you get
tenths of percentages. multiply by 10000 and divide by total
and you get hundredths of percentages. etc etc etc raj
2005-01-28 */
/* when the accounting for interrupt time gets its act together,
we can use total_cpu_cycles rather than sanity_cpu_cycles, but
until then, use sanity_cpu_ccles. raj 2005/09/14 */
fraction_idle =
(delta_cpu_counters[i].idle * CALC_ACCURACY) / sanity_cpu_cycles;
fraction_user =
(delta_cpu_counters[i].user * CALC_ACCURACY) / sanity_cpu_cycles;
fraction_kernel =
(delta_cpu_counters[i].kernel * CALC_ACCURACY) / sanity_cpu_cycles;
fraction_interrupt =
(delta_cpu_counters[i].interrupt * CALC_ACCURACY) / sanity_cpu_cycles;
estimated_fraction_interrupt =
((delta_cpu_counters[i].interrupt +
(sanity_cpu_cycles - total_cpu_cycles)) *
CALC_ACCURACY) / sanity_cpu_cycles;
if (debug) {
fprintf(where,
"\tfraction_idle %"PRIu64"\n"
"\tfraction_user %"PRIu64"\n"
"\tfraction_kernel %"PRIu64"\n"
"\tfraction_interrupt %"PRIu64"WARNING, possibly under-counted!\n"
"\testimated_fraction_interrupt %"PRIu64"\n",
fraction_idle,
fraction_user,
fraction_kernel,
fraction_interrupt,
estimated_fraction_interrupt);
}
/* and finally, what is our CPU utilization? */
lib_local_per_cpu_util[i] = 100.0 - (((float)fraction_idle /
(float)CALC_ACCURACY) * 100.0);
#endif
lib_local_per_cpu_util[i] *= correction_factor;
if (debug) {
fprintf(where,
"lib_local_per_cpu_util[%d] %g cf %f\n",
i,
lib_local_per_cpu_util[i],
correction_factor);
}
lib_local_cpu_stats.cpu_util += lib_local_per_cpu_util[i];
}
/* we want the average across all n processors */
lib_local_cpu_stats.cpu_util /= (float)lib_num_loc_cpus;
if (debug) {
fprintf(where,
"calc_cpu_util: returning %g\n",
lib_local_cpu_stats.cpu_util);
}
return lib_local_cpu_stats.cpu_util;
}
void
cpu_start_internal(void)
{
get_cpu_counters(starting_cpu_counters);
}
void
cpu_stop_internal(void)
{
get_cpu_counters(ending_cpu_counters);
}