static int
check_papi_state()
{
int state = 0;
int sts;
sts = PAPI_state(EventSet, &state);
if (sts != PAPI_OK)
return sts;
return state;
}
void HWCBE_PAPI_CleanUp (unsigned nthreads)
{
UNREFERENCED_PARAMETER(nthreads);
if (PAPI_is_initialized())
{
int state;
int i;
unsigned t;
if (PAPI_state (HWCEVTSET(THREADID), &state) == PAPI_OK)
{
if (state & PAPI_RUNNING)
{
long long tmp[MAX_HWC];
PAPI_stop (HWCEVTSET(THREADID), tmp);
}
}
for (i = 0; i < HWC_num_sets; i++)
{
for (t = 0; t < nthreads; t++)
{
/* Remove all events in the eventset and destroy the eventset */
PAPI_cleanup_eventset(HWC_sets[i].eventsets[t]);
PAPI_destroy_eventset(&HWC_sets[i].eventsets[t]);
}
xfree (HWC_sets[i].eventsets);
}
#if defined(PAPI_SAMPLING_SUPPORT)
for (i = 0; i < HWC_num_sets; i++)
{
/* Free extra allocated memory */
if (HWC_sets[i].NumOverflows > 0)
{
xfree (HWC_sets[i].OverflowValue);
xfree (HWC_sets[i].OverflowCounter);
}
}
#endif
xfree (HWC_sets);
PAPI_shutdown();
}
}
static int
papi_fetchCallBack(pmdaMetric *mdesc, unsigned int inst, pmAtomValue *atom)
{
__pmID_int *idp = (__pmID_int *)&(mdesc->m_desc.pmid);
int sts;
int i;
int state;
char local_string[PAPI_HUGE_STR_LEN+12];
static char status_string[4096];
int first_metric = 0;
time_t now;
now = time(NULL);
switch (idp->cluster) {
case CLUSTER_PAPI:
if (idp->item >= 0 && idp->item <= number_of_events) {
// the 'case' && 'idp->item' value we get is the pmns_position
if (papi_info[idp->item].position >= 0) { // live counter?
atom->ll = papi_info[idp->item].prev_value + values[papi_info[idp->item].position];
return PMDA_FETCH_STATIC;
}
else { // inactive counter?
if (papi_info[idp->item].metric_enabled) { // but requested?
papi_info[idp->item].metric_enabled = 0; // give up
return PM_ERR_VALUE; // i.e., expect no values ever
}
return PMDA_FETCH_NOVALUES;
}
}
return PM_ERR_PMID;
case CLUSTER_CONTROL:
switch (idp->item) {
case CONTROL_ENABLE:
atom->cp = "";
return PMDA_FETCH_STATIC;
case CONTROL_RESET:
atom->cp = "";
return PMDA_FETCH_STATIC;
case CONTROL_DISABLE:
atom->cp = "";
if ((sts = check_papi_state()) & PAPI_RUNNING)
return PMDA_FETCH_STATIC;
return 0;
case CONTROL_STATUS:
sts = PAPI_state(EventSet, &state);
if (sts != PAPI_OK)
return PM_ERR_VALUE;
strcpy(status_string, "Papi ");
if(state & PAPI_STOPPED)
strcat(status_string, "is stopped, ");
if (state & PAPI_RUNNING)
strcat(status_string, "is running, ");
if (state & PAPI_PAUSED)
strcat(status_string,"is paused, ");
if (state & PAPI_NOT_INIT)
strcat(status_string, "is defined but not initialized, ");
if (state & PAPI_OVERFLOWING)
strcat(status_string, "has overflowing enabled, ");
if (state & PAPI_PROFILING)
strcat(status_string, "eventset has profiling enabled, ");
if (state & PAPI_MULTIPLEXING)
strcat(status_string,"has multiplexing enabled, ");
if (state & PAPI_ATTACHED)
strcat(status_string, "is attached to another process/thread, ");
if (state & PAPI_CPU_ATTACHED)
strcat(status_string, "is attached to a specific CPU, ");
first_metric = 1;
for(i = 0; i < number_of_events; i++){
if(papi_info[i].position < 0)
continue;
sprintf(local_string, "%s%s(%d): %lld",
(first_metric ? "" : ", "),
papi_info[i].papi_string_code,
(papi_info[i].metric_enabled == METRIC_ENABLED_FOREVER ? -1 :
(int)(papi_info[i].metric_enabled - now)), // number of seconds left
(papi_info[i].prev_value + values[papi_info[i].position]));
first_metric = 0;
if ((strlen(status_string) + strlen(local_string) + 1) < sizeof(status_string))
strcat(status_string, local_string);
}
atom->cp = status_string;
return PMDA_FETCH_STATIC;
case CONTROL_AUTO_ENABLE:
atom->ul = auto_enable_time;
return PMDA_FETCH_STATIC;
case CONTROL_MULTIPLEX:
atom->ul = enable_multiplexing;
return PMDA_FETCH_STATIC;
default:
return PM_ERR_PMID;
}
break;
case CLUSTER_AVAILABLE:
if (idp->item == AVAILABLE_NUM_COUNTERS) {
atom->ul = number_of_counters;
return PMDA_FETCH_STATIC;
}
if (idp->item == AVAILABLE_VERSION) {
atom->cp = papi_version;
return PMDA_FETCH_STATIC;
}
return PM_ERR_PMID;
default:
return PM_ERR_PMID;
}
return PMDA_FETCH_NOVALUES;
}
