#include <string.h>
#include <unistd.h>
/* Headers required by PAPI */
#include "papi.h"
#include "papi_internal.h"
#include "papi_vector.h"
#include "papi_memory.h"
#include "linux-micpower.h"
/* Intel says
----
The power measurements can be obtained from the host as well as the MIC card
over a 50msec interval. The SMC is designed to sample power consumption only
every 50mSecs.
----
**/
#define REFRESH_LAT 50000
#define INVALID_RESULT -1000000L
#define MICPOWER_NUMBER_OF_NATIVE_EVENTS 16
papi_vector_t _micpower_vector;
static MICPOWER_native_event_entry_t _micpower_native_events[] = {
{ .name = "tot0",
.units = "uW",
.description = "Total power, win 0",
.resources.selector = 1
},
{ .name = "tot1",
.units = "uW",
.description = "Total power, win 1",
.resources.selector = 2
},
{ .name = "pcie",
.units = "uW",
.description = "PCI-E connector power",
.resources.selector = 3
},
{ .name = "inst",
.units = "uW",
.description = "Instantaneous power",
.resources.selector = 4
},
{ .name = "imax",
.units = "uW",
.description = "Max Instantaneous power",
.resources.selector = 5
},
{ .name = "c2x3",
.units = "uW",
.description = "2x3 connector power",
.resources.selector = 6
},
{ .name = "c2x4",
.units = "uW",
.description = "2x4 connector power",
.resources.selector = 7
},
{ .name = "vccp:pwr",
.units = "uW",
.description = "Core rail; Power reading",
.resources.selector = 8
},
{ .name = "vccp:cur",
.units = "uA",
.description = "Core rail; Current",
.resources.selector = 9
},
{ .name = "vccp:volt",
.units = "uV",
.description = "Core rail; Voltage",
.resources.selector = 10
},
{ .name = "vddg:pwr",
.units = "uW",
.description = "Uncore rail; Power reading",
.resources.selector = 11
},
{ .name = "vddg:cur",
.units = "uA",
.description = "Uncore rail; Current",
.resources.selector = 12
},
{ .name = "vddg:volt",
.units = "uV",
.description = "Uncore rail; Voltage",
.resources.selector = 13
},
{ .name = "vddq:pwr",
.units = "uW",
.description = "Memory subsystem rail; Power reading",
.resources.selector = 14
},
{ .name = "vddq:cur",
.units = "uA",
.description = "Memory subsystem rail; Current",
.resources.selector = 15
},
{ .name = "vddq:volt",
.units = "uV",
.description = "Memory subsystem rail; Voltage",
.resources.selector = 16
}
};
static int num_events = 0;
static int is_initialized = 0;
/***************************************************************************/
/****** BEGIN FUNCTIONS USED INTERNALLY SPECIFIC TO THIS COMPONENT *******/
/***************************************************************************/
#if 0
From Intel docs, power readings are exported via sysfs at
/sys/class/micras/power
typedeftruct mr_rsp_pws { /* Power status */
uint32_t prr; /* Current reading, in uW */
uint8_t p_val; /* Valid bits, power */
} MrRspPws;
typedef struct mr_rsp_vrr { /* Voltage regulator status */
uint32_t pwr; /* Power reading, in uW */
uint32_t cur; /* Current, in uA */
uint32_t volt; /* Voltage, in uV */
uint8_t p_val; /* Valid bits, power */
uint8_t c_val; /* Valid bits, current */
uint8_t v_val; /* Valid bits, voltage */
} MrRspVrr;
I am assuming for the purposes of this component that only
the readings are exported.
typedef struct mr_rsp_power {
MrRspPws tot0; /* Total power, win 0 */
MrRspPws tot1; /* Total power, win 1 */
MrRspPws pcie; /* PCI-E connector power */
MrRspPws inst; /* Instantaneous power */
MrRspPws imax; /* Max Instantaneous power */
MrRspPws c2x3; /* 2x3 connector power */
MrRspPws c2x4; /* 2x4 connector power */
MrRspVrr vccp; /* Core rail */
MrRspVrr vddg; /* Uncore rail */
MrRspVrr vddq; /* Memory subsystem rail */
} MrRspPower;
#endif
static int
read_sysfs_file( long long* counts)
{
FILE* fp = NULL;
int i;
int retval = 1;
fp = fopen( "/sys/class/micras/power", "r" );
if (!fp)
return 0;
for (i=0; i < MICPOWER_MAX_COUNTERS-9; i++) {
retval&= fscanf(fp, "%lld", &counts[i]);
}
for (i=MICPOWER_MAX_COUNTERS-9; i < MICPOWER_MAX_COUNTERS; i+=3) {
retval&= fscanf(fp, "%lld %lld %lld", &counts[i], &counts[i+1], &counts[i+2] );
}
fclose(fp);
return retval;
}
/*****************************************************************************
******************* BEGIN PAPI's COMPONENT REQUIRED FUNCTIONS *************
*****************************************************************************/
/*
* This is called whenever a thread is initialized
*/
static int
_micpower_init_thread( hwd_context_t *ctx )
{
( void ) ctx;
return PAPI_OK;
}
/* Initialize hardware counters, setup the function vector table
* and get hardware information, this routine is called when the
* PAPI process is initialized (IE PAPI_library_init)
*/
static int
_micpower_init_component( int cidx )
{
if ( is_initialized )
return (PAPI_OK );
is_initialized = 1;
/* Check that /sys/class/micras/power is readable */
if ( 0 != access( "/sys/class/micras/power", R_OK ) ) {
strncpy(_micpower_vector.cmp_info.disabled_reason,
"Cannot read /sys/class/micras/power",PAPI_MAX_STR_LEN);
return PAPI_ENOCMP;
}
/* Export the total number of events available */
num_events =
_micpower_vector.cmp_info.num_native_events = MICPOWER_NUMBER_OF_NATIVE_EVENTS;
/* Export the component id */
_micpower_vector.cmp_info.CmpIdx = cidx;
return PAPI_OK;
}
/*
* Control of counters (Reading/Writing/Starting/Stopping/Setup)
* functions
*/
static int
_micpower_init_control_state( hwd_control_state_t * ctl)
{
int retval = 0;
MICPOWER_control_state_t *micpower_ctl = (MICPOWER_control_state_t *) ctl;
retval = read_sysfs_file(micpower_ctl->counts);
/* Set last access time for caching results */
micpower_ctl->lastupdate = PAPI_get_real_usec();
return (retval)?PAPI_OK:PAPI_ESYS;
}
static int
_micpower_start( hwd_context_t *ctx, hwd_control_state_t *ctl)
{
( void ) ctx;
( void ) ctl;
return PAPI_OK;
}
static int
_micpower_read( hwd_context_t *ctx, hwd_control_state_t *ctl,
long long ** events, int flags)
{
(void) flags;
(void) ctx;
int retval = 1;
MICPOWER_control_state_t* control = (MICPOWER_control_state_t*) ctl;
long long now = PAPI_get_real_usec();
/* Only read the values from the kernel if enough time has passed */
/* since the last read. Otherwise return cached values. */
if ( now - control->lastupdate > REFRESH_LAT ) {
retval = read_sysfs_file(control->counts);
control->lastupdate = now;
}
/* Pass back a pointer to our results */
*events = control->counts;
return (retval)?PAPI_OK:PAPI_ESYS;
}
static int
_micpower_stop( hwd_context_t *ctx, hwd_control_state_t *ctl )
{
(void) ctx;
int retval = 1;
long long now = PAPI_get_real_usec();
/* read values */
MICPOWER_control_state_t* control = (MICPOWER_control_state_t*) ctl;
if ( now - control->lastupdate > REFRESH_LAT ) {
retval = read_sysfs_file(control->counts);
control->lastupdate = now;
}
return (retval)?PAPI_OK:PAPI_ESYS;
}
/* Shutdown a thread */
static int
_micpower_shutdown_thread( hwd_context_t * ctx )
{
( void ) ctx;
return PAPI_OK;
}
/*
* Clean up what was setup in micpower_init_component().
*/
static int
_micpower_shutdown_component( )
{
if ( is_initialized ) {
is_initialized = 0;
num_events = 0;
}
return PAPI_OK;
}
/* This function sets various options in the component
* The valid codes being passed in are PAPI_SET_DEFDOM,
* PAPI_SET_DOMAIN, PAPI_SETDEFGRN, PAPI_SET_GRANUL * and PAPI_SET_INHERIT
*/
static int
_micpower_ctl( hwd_context_t *ctx, int code, _papi_int_option_t *option )
{
( void ) ctx;
( void ) code;
( void ) option;
return PAPI_OK;
}
static int
_micpower_update_control_state( hwd_control_state_t *ptr,
NativeInfo_t * native, int count,
hwd_context_t * ctx )
{
int i, index;
( void ) ctx;
( void ) ptr;
for ( i = 0; i < count; i++ ) {
index = native[i].ni_event&PAPI_NATIVE_AND_MASK;
native[i].ni_position = _micpower_native_events[index].resources.selector - 1;
}
return PAPI_OK;
}
/*
* This function has to set the bits needed to count different domains
* In particular: PAPI_DOM_USER, PAPI_DOM_KERNEL PAPI_DOM_OTHER
* By default return PAPI_EINVAL if none of those are specified
* and PAPI_OK with success
* PAPI_DOM_USER is only user context is counted
* PAPI_DOM_KERNEL is only the Kernel/OS context is counted
* PAPI_DOM_OTHER is Exception/transient mode (like user TLB misses)
* PAPI_DOM_ALL is all of the domains
*/
static int
_micpower_set_domain( hwd_control_state_t * cntl, int domain )
{
( void ) cntl;
if ( PAPI_DOM_ALL != domain )
return PAPI_EINVAL;
return PAPI_OK;
}
static int
_micpower_reset( hwd_context_t *ctx, hwd_control_state_t *ctl )
{
( void ) ctx;
( void ) ctl;
return PAPI_OK;
}
/*
* Native Event functions
*/
static int
_micpower_ntv_enum_events( unsigned int *EventCode, int modifier )
{
int index;
switch ( modifier ) {
case PAPI_ENUM_FIRST:
if (num_events==0) {
return PAPI_ENOEVNT;
}
*EventCode = 0;
return PAPI_OK;
case PAPI_ENUM_EVENTS:
index = *EventCode&PAPI_NATIVE_AND_MASK;
if ( index < num_events - 1 ) {
*EventCode = *EventCode + 1;
return PAPI_OK;
} else {
return PAPI_ENOEVNT;
}
break;
default:
return PAPI_EINVAL;
}
return PAPI_EINVAL;
}
/*
*
*/
static int
_micpower_ntv_code_to_name( unsigned int EventCode, char *name, int len )
{
int index = EventCode&PAPI_NATIVE_AND_MASK;
if ( index >= 0 && index < num_events ) {
strncpy( name, _micpower_native_events[index].name, len );
return PAPI_OK;
}
return PAPI_ENOEVNT;
}
/*
*
*/
static int
_micpower_ntv_code_to_descr( unsigned int EventCode, char *name, int len )
{
int index = EventCode&PAPI_NATIVE_AND_MASK;
if ( index >= 0 && index < num_events ) {
strncpy( name, _micpower_native_events[index].description, len );
return PAPI_OK;
}
return PAPI_ENOEVNT;
}
static int
_micpower_ntv_code_to_info(unsigned int EventCode, PAPI_event_info_t *info)
{
int index = EventCode&PAPI_NATIVE_AND_MASK;
if ( ( index < 0) || (index >= num_events )) return PAPI_ENOEVNT;
strncpy( info->symbol, _micpower_native_events[index].name, sizeof(info->symbol));
strncpy( info->long_descr, _micpower_native_events[index].description, sizeof(info->long_descr));
strncpy( info->units, _micpower_native_events[index].units, sizeof(info->units));
info->units[sizeof(info->units)-1] = '\0';
return PAPI_OK;
}
/*
*
*/
papi_vector_t _micpower_vector = {
.cmp_info = {
/* default component information (unspecified values are initialized to 0) */
.name = "micpower",
.short_name = "micpower",
.description = "Component for reading power on Intel Xeon Phi (MIC)",
.version = "5.1",
.num_mpx_cntrs = MICPOWER_NUMBER_OF_NATIVE_EVENTS,
.num_cntrs = MICPOWER_NUMBER_OF_NATIVE_EVENTS,
.default_domain = PAPI_DOM_ALL,
.available_domains = PAPI_DOM_ALL,
.default_granularity = PAPI_GRN_SYS,
.available_granularities = PAPI_GRN_SYS,
.hardware_intr_sig = PAPI_INT_SIGNAL,
/* component specific cmp_info initializations */
.fast_real_timer = 0,
.fast_virtual_timer = 0,
.attach = 0,
.attach_must_ptrace = 0,
}
,
/* sizes of framework-opaque component-private structures */
.size = {
.context = sizeof ( MICPOWER_context_t ),
.control_state = sizeof ( MICPOWER_control_state_t ),
.reg_value = sizeof ( MICPOWER_register_t ),
.reg_alloc = sizeof ( MICPOWER_reg_alloc_t ),
}
,
/* function pointers in this component */
.init_thread = _micpower_init_thread,
.init_component = _micpower_init_component,
.init_control_state = _micpower_init_control_state,
.start = _micpower_start,
.stop = _micpower_stop,
.read = _micpower_read,
.shutdown_thread = _micpower_shutdown_thread,
.shutdown_component = _micpower_shutdown_component,
.ctl = _micpower_ctl,
.update_control_state = _micpower_update_control_state,
.set_domain = _micpower_set_domain,
.reset = _micpower_reset,
.ntv_enum_events = _micpower_ntv_enum_events,
.ntv_code_to_name = _micpower_ntv_code_to_name,
.ntv_code_to_descr = _micpower_ntv_code_to_descr,
.ntv_code_to_info = _micpower_ntv_code_to_info,
};