static int
refresh_interrupts(pmdaExt *pmda, __pmnsTree **tree)
{
int i, sts, dom = pmda->e_domain;
if (interrupt_tree) {
*tree = interrupt_tree;
} else if ((sts = __pmNewPMNS(&interrupt_tree)) < 0) {
__pmNotifyErr(LOG_ERR, "%s: failed to create interrupt names: %s\n",
pmProgname, pmErrStr(sts));
*tree = NULL;
} else if ((sts = refresh_interrupt_values()) < 0) {
__pmNotifyErr(LOG_ERR, "%s: failed to update interrupt values: %s\n",
pmProgname, pmErrStr(sts));
*tree = NULL;
} else {
for (i = 0; i < lines_count; i++)
update_lines_pmns(dom, i, interrupt_lines[i].id);
for (i = 0; i < other_count; i++)
update_other_pmns(dom, i, interrupt_other[i].name);
*tree = interrupt_tree;
pmdaTreeRebuildHash( interrupt_tree, lines_count+other_count );
return 1;
}
return 0;
}
static int
refresh_sbstats(pmdaExt *pmda, __pmnsTree **tree)
{
int t, s, sts;
static __pmnsTree *sbstats_tree;
if (sbstats_tree) {
*tree = sbstats_tree;
} else if ((sts = __pmNewPMNS(&sbstats_tree)) < 0) {
__pmNotifyErr(LOG_ERR, "%s: failed to create sbstats names: %s\n",
pmProgname, pmErrStr(sts));
*tree = NULL;
} else {
for (t = 0; t < NUM_LOCKTYPES; t++)
for (s = 0; s < NUM_LOCKSTATS; s++)
add_pmns_node(sbstats_tree, pmda->e_domain, CLUSTER_SBSTATS, t, s);
*tree = sbstats_tree;
pmdaTreeRebuildHash( sbstats_tree, NUM_LOCKTYPES*NUM_LOCKSTATS );
return 1;
}
return 0;
}
void
logger_init(pmdaInterface *dp, const char *configfile)
{
size_t size;
int i, j, sts, item, numloggers;
int numstatics = sizeof(static_metrictab)/sizeof(static_metrictab[0]);
int numdynamics = sizeof(dynamic_metrictab)/sizeof(dynamic_metrictab[0]);
pmdaMetric *pmetric;
char name[MAXPATHLEN * 2];
dynamic_metric_info_t *pinfo;
__pmSetProcessIdentity(username);
/* Read and parse config file. */
if ((numloggers = event_config(configfile)) < 0)
return;
/* Create the dynamic metric info table based on the logfile table */
size = sizeof(struct dynamic_metric_info) * numdynamics * numloggers;
if ((dynamic_metric_infotab = malloc(size)) == NULL) {
__pmNoMem("logger_init(dynamic)", size, PM_FATAL_ERR);
return;
}
pinfo = dynamic_metric_infotab;
for (i = 0; i < numloggers; i++) {
for (j = 0; j < numdynamics; j++) {
pinfo->handle = i;
pinfo->pmid_index = j;
pinfo->help_text = dynamic_helptab[j];
pinfo++;
}
}
/* Create the metric table based on the static and dynamic metric tables */
nummetrics = numstatics + (numloggers * numdynamics);
size = sizeof(pmdaMetric) * nummetrics;
if ((metrictab = malloc(size)) == NULL) {
free(dynamic_metric_infotab);
__pmNoMem("logger_init(static)", size, PM_FATAL_ERR);
return;
}
memcpy(metrictab, static_metrictab, sizeof(static_metrictab));
pmetric = &metrictab[numstatics];
pinfo = dynamic_metric_infotab;
item = numstatics;
for (i = 0; i < numloggers; i++) {
memcpy(pmetric, dynamic_metrictab, sizeof(dynamic_metrictab));
for (j = 0; j < numdynamics; j++) {
pmetric[j].m_desc.pmid = PMDA_PMID(0, item++);
pmetric[j].m_user = pinfo++;
}
pmetric += numdynamics;
}
if (dp->status != 0)
return;
dp->version.four.fetch = logger_fetch;
dp->version.four.store = logger_store;
dp->version.four.profile = logger_profile;
dp->version.four.pmid = logger_pmid;
dp->version.four.name = logger_name;
dp->version.four.children = logger_children;
dp->version.four.text = logger_text;
pmdaSetFetchCallBack(dp, logger_fetchCallBack);
pmdaSetEndContextCallBack(dp, logger_end_contextCallBack);
pmdaInit(dp, NULL, 0, metrictab, nummetrics);
/* Create the dynamic PMNS tree and populate it. */
if ((sts = __pmNewPMNS(&pmns)) < 0) {
__pmNotifyErr(LOG_ERR, "%s: failed to create new pmns: %s\n",
pmProgname, pmErrStr(sts));
pmns = NULL;
return;
}
pmetric = &metrictab[numstatics];
for (i = 0; i < numloggers; i++) {
const char *id = event_pmnsname(i);
for (j = 0; j < numdynamics; j++) {
snprintf(name, sizeof(name),
"logger.perfile.%s.%s", id, dynamic_nametab[j]);
__pmAddPMNSNode(pmns, pmetric[j].m_desc.pmid, name);
}
pmetric += numdynamics;
}
/* for reverse (pmid->name) lookups */
pmdaTreeRebuildHash(pmns, (numloggers * numdynamics));
/* initialise the event and client tracking code */
event_init(metrictab[2].m_desc.pmid);
}
static int
papi_internal_init(pmdaInterface *dp)
{
int ec;
int sts;
PAPI_event_info_t info;
char entry[PAPI_HUGE_STR_LEN+12]; // the length papi uses for the symbol name
unsigned int i = 0;
pmID pmid;
sts = sprintf(papi_version, "%d.%d.%d", PAPI_VERSION_MAJOR(PAPI_VERSION),
PAPI_VERSION_MINOR(PAPI_VERSION), PAPI_VERSION_REVISION(PAPI_VERSION));
if (sts < 0) {
__pmNotifyErr(LOG_ERR, "%s failed to create papi version metric.\n",pmProgname);
return PM_ERR_GENERIC;
}
if ((sts = __pmNewPMNS(&papi_tree)) < 0) {
__pmNotifyErr(LOG_ERR, "%s failed to create dynamic papi pmns: %s\n",
pmProgname, pmErrStr(sts));
papi_tree = NULL;
return PM_ERR_GENERIC;
}
number_of_counters = PAPI_num_counters();
if (number_of_counters < 0) {
__pmNotifyErr(LOG_ERR, "hardware does not support performance counters\n");
return PM_ERR_APPVERSION;
}
else if (number_of_counters == 0) {
__pmNotifyErr(LOG_WARNING, "no performance counters\n");
}
sts = PAPI_library_init(PAPI_VER_CURRENT);
if (sts != PAPI_VER_CURRENT) {
__pmNotifyErr(LOG_ERR, "PAPI_library_init error (%d)\n", sts);
return PM_ERR_GENERIC;
}
ec = PAPI_PRESET_MASK;
PAPI_enum_event(&ec, PAPI_ENUM_FIRST);
do {
if (PAPI_get_event_info(ec, &info) == PAPI_OK) {
if (info.count && PAPI_PRESET_ENUM_AVAIL) {
expand_papi_info(i);
memcpy(&papi_info[i].info, &info, sizeof(PAPI_event_info_t));
memcpy(&papi_info[i].papi_string_code, info.symbol + 5, strlen(info.symbol)-5);
snprintf(entry, sizeof(entry),"papi.system.%s", papi_info[i].papi_string_code);
pmid = pmid_build(dp->domain, CLUSTER_PAPI, i);
papi_info[i].pmid = pmid;
__pmAddPMNSNode(papi_tree, pmid, entry);
memset(&entry[0], 0, sizeof(entry));
papi_info[i].position = -1;
papi_info[i].metric_enabled = 0;
expand_values(i);
i++;
}
}
} while(PAPI_enum_event(&ec, 0) == PAPI_OK);
#if defined(HAVE_PAPI_DISABLED_COMP)
char *tokenized_string;
int number_of_components;
int component_id;
int native;
number_of_components = PAPI_num_components();
native = 0 | PAPI_NATIVE_MASK;
for (component_id = 0; component_id < number_of_components; component_id++) {
const PAPI_component_info_t *component;
component = PAPI_get_component_info(component_id);
if (component->disabled || (strcmp("perf_event", component->name)
&& strcmp("perf_event_uncore", component->name)))
continue;
sts = PAPI_enum_cmp_event (&native, PAPI_ENUM_FIRST, component_id);
if (sts == PAPI_OK)
do {
if (PAPI_get_event_info(native, &info) == PAPI_OK) {
char local_native_metric_name[PAPI_HUGE_STR_LEN] = "";
int was_tokenized = 0;
expand_papi_info(i);
memcpy(&papi_info[i].info, &info, sizeof(PAPI_event_info_t));
tokenized_string = strtok(info.symbol, "::: -");
while (tokenized_string != NULL) {
size_t remaining = sizeof(local_native_metric_name) -
strlen(local_native_metric_name) - 1;
if (remaining < 1)
break;
strncat(local_native_metric_name, tokenized_string, remaining);
was_tokenized = 1;
tokenized_string=strtok(NULL, "::: -");
if (tokenized_string) {
remaining = sizeof(local_native_metric_name) -
strlen(local_native_metric_name) - 1;
if (remaining < 1)
break;
strncat(local_native_metric_name, ".", remaining);
}
}
if (!was_tokenized) {
strncpy(papi_info[i].papi_string_code, info.symbol,
sizeof(papi_info[i].papi_string_code) - 1);
}
else {
strncpy(papi_info[i].papi_string_code,
local_native_metric_name,
sizeof(papi_info[i].papi_string_code) - 1);
}
snprintf(entry, sizeof(entry),"papi.system.%s", papi_info[i].papi_string_code);
pmid = pmid_build(dp->domain, CLUSTER_PAPI, i);
papi_info[i].pmid = pmid;
__pmAddPMNSNode(papi_tree, pmid, entry);
memset(&entry[0], 0, sizeof(entry));
papi_info[i].position = -1;
papi_info[i].metric_enabled = 0;
expand_values(i);
i++;
}
} while (PAPI_enum_cmp_event(&native, PAPI_ENUM_EVENTS, component_id) == PAPI_OK);
}
#endif
pmdaTreeRebuildHash(papi_tree, number_of_events);
/* Set one-time settings for all future EventSets. */
if ((sts = PAPI_set_domain(PAPI_DOM_ALL)) != PAPI_OK) {
handle_papi_error(sts, 0);
return PM_ERR_GENERIC;
}
if ((sts = PAPI_multiplex_init()) != PAPI_OK) {
handle_papi_error(sts, 0);
return PM_ERR_GENERIC;
}
sts = refresh_metrics(0);
if (sts != PAPI_OK)
return PM_ERR_GENERIC;
return 0;
}