linux-powercap-ppc.c File Reference

Include dependency graph for linux-powercap-ppc.c:

Go to the source code of this file.

Macros
#define	HANDLE_STRING_ERROR   {fprintf(stderr,"%s:%i unexpected string function error.\n",__FILE__,__LINE__); exit(-1);}

Functions
static char *	_local_strlcpy (char *dst, const char *src, size_t size)
static long long	read_powercap_value (int index)
static int	write_powercap_value (int index, long long value)
static int	_powercap_ppc_init_thread (hwd_context_t *ctx)
static int	_powercap_ppc_init_component (int cidx)
static int	_powercap_ppc_init_control_state (hwd_control_state_t *ctl)
static int	_powercap_ppc_update_control_state (hwd_control_state_t *ctl, NativeInfo_t *native, int count, hwd_context_t *ctx)
static int	_powercap_ppc_start (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_powercap_ppc_stop (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_powercap_ppc_shutdown_thread (hwd_context_t *ctx)
static int	_powercap_ppc_read (hwd_context_t *ctx, hwd_control_state_t *ctl, long long **events, int flags)
static int	_powercap_ppc_write (hwd_context_t *ctx, hwd_control_state_t *ctl, long long *values)
static int	_powercap_ppc_shutdown_component (void)
static int	_powercap_ppc_ctl (hwd_context_t *ctx, int code, _papi_int_option_t *option)
static int	_powercap_ppc_set_domain (hwd_control_state_t *ctl, int domain)
static int	_powercap_ppc_reset (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_powercap_ppc_ntv_enum_events (unsigned int *EventCode, int modifier)
static int	_powercap_ppc_ntv_code_to_name (unsigned int EventCode, char *name, int len)
static int	_powercap_ppc_ntv_code_to_info (unsigned int EventCode, PAPI_event_info_t *info)
static int	_powercap_ppc_ntv_name_to_code (const char *name, unsigned int *EventCode)

Variables
static char	read_buff [PAPI_MAX_STR_LEN]
static char	write_buff [PAPI_MAX_STR_LEN]
static int	num_events =0
static int	pkg_events [PKG_NUM_EVENTS] = {PKG_MIN_POWER, PKG_MAX_POWER, PKG_CUR_POWER}
static const char *	pkg_event_names [PKG_NUM_EVENTS] = {"MIN_POWER", "MAX_POWER", "CURRENT_POWER"}
static const char *	pkg_sys_names [PKG_NUM_EVENTS] = {"powercap-min", "powercap-max", "powercap-current"}
static const char *	pkg_event_descs [PKG_NUM_EVENTS]
static mode_t	pkg_sys_flags [PKG_NUM_EVENTS] = {O_RDONLY, O_RDONLY, O_RDWR}
static _powercap_ppc_native_event_entry_t	powercap_ppc_ntv_events [(PKG_NUM_EVENTS)]
static int	event_fds [POWERCAP_MAX_COUNTERS]
papi_vector_t	_powercap_ppc_vector

Macro Definition Documentation

HANDLE_STRING_ERROR

#define HANDLE_STRING_ERROR   {fprintf(stderr,"%s:%i unexpected string function error.\n",__FILE__,__LINE__); exit(-1);}

Definition at line 27 of file linux-powercap-ppc.c.

Function Documentation

_local_strlcpy()

static char * _local_strlcpy ( char *  dst, const char *  src, size_t  size  )

static

Definition at line 60 of file linux-powercap-ppc.c.

{
    char *retval = strncpy( dst, src, size );
    if ( size > 0 ) dst[size-1] = '\0';
 
    return( retval );
}

Here is the caller graph for this function:

_powercap_ppc_ctl()

static int _powercap_ppc_ctl ( hwd_context_t *  ctx, int  code, _papi_int_option_t *  option  )

static

Definition at line 328 of file linux-powercap-ppc.c.

{
    SUBDBG( "Enter: ctx: %p\n", ctx );
    (void) ctx;
    (void) code;
    (void) option;
 
    return PAPI_OK;
}

_powercap_ppc_init_component()

static int _powercap_ppc_init_component ( int  cidx )

static

Definition at line 111 of file linux-powercap-ppc.c.

{
    int retval = PAPI_OK;
    int e = -1;
    char events_dir[128];
    char event_path[128];
    char *strCpy;
 
    DIR *events;
 
    const PAPI_hw_info_t *hw_info;
    hw_info=&( _papi_hwi_system_info.hw_info );
 
    /* check if IBM processor */
    if ( hw_info->vendor!=PAPI_VENDOR_IBM ) {
        strCpy=strncpy(_powercap_ppc_vector.cmp_info.disabled_reason, "Not an IBM Power9 processor", PAPI_MAX_STR_LEN);
        _powercap_ppc_vector.cmp_info.disabled_reason[PAPI_MAX_STR_LEN-1]=0;
        if (strCpy == NULL) HANDLE_STRING_ERROR;
        retval = PAPI_ENOSUPP;
        goto fn_fail;
    }
 
    num_events = 0;
 
    /* Check the existence, and correct access modes to pkg directory path */
    size_t ret = snprintf(events_dir, sizeof(events_dir), "/sys/firmware/opal/powercap/system-powercap/");
    if (ret <= 0 || sizeof(events_dir) <= ret) HANDLE_STRING_ERROR;
 
    if ( NULL == (events = opendir(events_dir)) ) {
        strCpy=strncpy(_powercap_ppc_vector.cmp_info.disabled_reason,
            "Directory /sys/firmware/opal/powercap/system-powercap missing.",
            PAPI_MAX_STR_LEN);
        _powercap_ppc_vector.cmp_info.disabled_reason[PAPI_MAX_STR_LEN-1]=0;
        if (strCpy == NULL) HANDLE_STRING_ERROR;
        retval = PAPI_ENOSUPP;
        goto fn_fail;
    }
 
    /* opendir needs clean up. */
    closedir(events);
 
    /* loop through events and create powercap event entries */
    for ( e = 0; e < PKG_NUM_EVENTS; ++e ) {
        /* compose string to individual event */
        size_t ret = snprintf(event_path, sizeof(event_path), "%s%s", events_dir, pkg_sys_names[e]);
        if (ret <= 0 || sizeof(event_path) <= ret) HANDLE_STRING_ERROR;
 
        /* if it's not a valid pkg event path we skip it */
        if (access(event_path, F_OK) == -1) continue;
 
        ret = snprintf(powercap_ppc_ntv_events[num_events].name,
                       sizeof(powercap_ppc_ntv_events[num_events].name),
                       "%s", pkg_event_names[e]);
        powercap_ppc_ntv_events[num_events].name[sizeof(powercap_ppc_ntv_events[num_events].name)-1]=0;
        if (ret <= 0 || sizeof(powercap_ppc_ntv_events[num_events].name) <= ret) HANDLE_STRING_ERROR;
 
        ret = snprintf(powercap_ppc_ntv_events[num_events].description,
                       sizeof(powercap_ppc_ntv_events[num_events].description),
                       "%s", pkg_event_descs[e]);
        powercap_ppc_ntv_events[num_events].description[sizeof(powercap_ppc_ntv_events[num_events].description)-1]=0;
        if (ret <= 0 || sizeof(powercap_ppc_ntv_events[num_events].description) <= ret) HANDLE_STRING_ERROR;
        ret = snprintf(powercap_ppc_ntv_events[num_events].units,
                       sizeof(powercap_ppc_ntv_events[num_events].units), "W");
        powercap_ppc_ntv_events[num_events].units[sizeof(powercap_ppc_ntv_events[num_events].units)-1]=0;
        if (ret <= 0 || sizeof(powercap_ppc_ntv_events[num_events].units) <= ret) HANDLE_STRING_ERROR;
 
        powercap_ppc_ntv_events[num_events].return_type = PAPI_DATATYPE_INT64;
        powercap_ppc_ntv_events[num_events].type = pkg_events[e];
 
        powercap_ppc_ntv_events[num_events].resources.selector = num_events + 1;
 
        event_fds[num_events] = open(event_path, O_SYNC|pkg_sys_flags[e]);
 
        num_events++;
    }
 
    /* Export the total number of events available */
    _powercap_ppc_vector.cmp_info.num_native_events = num_events;
    _powercap_ppc_vector.cmp_info.num_cntrs = num_events;
    _powercap_ppc_vector.cmp_info.num_mpx_cntrs = num_events;
 
    /* Export the component id */
    _powercap_ppc_vector.cmp_info.CmpIdx = cidx;
 
  fn_exit:
    _papi_hwd[cidx]->cmp_info.disabled = retval;
    return retval;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

_powercap_ppc_init_control_state()

static int _powercap_ppc_init_control_state ( hwd_control_state_t *  ctl )

static

Definition at line 208 of file linux-powercap-ppc.c.

{
    _powercap_ppc_control_state_t* control = ( _powercap_ppc_control_state_t* ) ctl;
    memset( control, 0, sizeof ( _powercap_ppc_control_state_t ) );
 
    return PAPI_OK;
}

_powercap_ppc_init_thread()

static int _powercap_ppc_init_thread ( hwd_context_t *  ctx )

static

Definition at line 100 of file linux-powercap-ppc.c.

{
    (void) ctx;
 
    return PAPI_OK;
}

_powercap_ppc_ntv_code_to_info()

static int _powercap_ppc_ntv_code_to_info ( unsigned int  EventCode, PAPI_event_info_t *  info  )

static

Definition at line 401 of file linux-powercap-ppc.c.

{
    int index = EventCode;
 
    if ( index < 0 || index >= num_events )
        return PAPI_ENOEVNT;
 
    _local_strlcpy( info->symbol, powercap_ppc_ntv_events[index].name, sizeof( info->symbol ) - 1 );
    _local_strlcpy( info->units, powercap_ppc_ntv_events[index].units, sizeof( info->units ) - 1 );
    _local_strlcpy( info->long_descr, powercap_ppc_ntv_events[index].description, sizeof( info->long_descr ) - 1 );
 
    info->data_type = powercap_ppc_ntv_events[index].return_type;
    return PAPI_OK;
}

Here is the call graph for this function:

_powercap_ppc_ntv_code_to_name()

static int _powercap_ppc_ntv_code_to_name ( unsigned int  EventCode, char *  name, int  len  )

static

Definition at line 388 of file linux-powercap-ppc.c.

{
    int index = EventCode & PAPI_NATIVE_AND_MASK;
 
    if ( index >= 0 && index < num_events ) {
        _local_strlcpy( name, powercap_ppc_ntv_events[index].name, len );
        return PAPI_OK;
    }
 
    return PAPI_ENOEVNT;
}

Here is the call graph for this function:

_powercap_ppc_ntv_enum_events()

static int _powercap_ppc_ntv_enum_events ( unsigned int *  EventCode, int  modifier  )

static

Definition at line 363 of file linux-powercap-ppc.c.

{
    int index;
    switch ( modifier ) {
        case PAPI_ENUM_FIRST:
            *EventCode = 0;
            return PAPI_OK;
        case PAPI_ENUM_EVENTS:
            index = *EventCode;
            if ( index < num_events - 1 ) {
                *EventCode = *EventCode + 1;
                return PAPI_OK;
            } else {
                return PAPI_ENOEVNT;
            }
 
        default:
            return PAPI_EINVAL;
    }
}

_powercap_ppc_ntv_name_to_code()

static int _powercap_ppc_ntv_name_to_code ( const char *  name, unsigned int *  EventCode  )

static

Definition at line 417 of file linux-powercap-ppc.c.

{
    if (!strcmp(name, "MIN_POWER")) *EventCode = 0;
    else if (!strcmp(name, "MAX_POWER")) *EventCode = 1;
    else if (!strcmp(name, "CURRENT_POWER")) *EventCode = 2;
    return PAPI_OK;
}

_powercap_ppc_read()

static int _powercap_ppc_read ( hwd_context_t *  ctx, hwd_control_state_t *  ctl, long long **  events, int  flags  )

static

Definition at line 271 of file linux-powercap-ppc.c.

{
    SUBDBG("Enter _powercap_ppc_read\n");
 
    (void) flags;
    (void) ctx;
    _powercap_ppc_control_state_t* control = ( _powercap_ppc_control_state_t* ) ctl;
 
    long long curr_val = 0;
 
    int c, i;
    for( c = 0; c < control->active_counters; c++ ) {
        i = control->which_counter[c];
        curr_val = read_powercap_value(i);
        SUBDBG("%d, current value %lld\n", i, curr_val);
        control->count[c]=curr_val;
    }
 
    *events = ( ( _powercap_ppc_control_state_t* ) ctl )->count;
 
    return PAPI_OK;
}

Here is the call graph for this function:

_powercap_ppc_reset()

static int _powercap_ppc_reset ( hwd_context_t *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 351 of file linux-powercap-ppc.c.

{
    (void) ctx;
    (void) ctl;
 
    return PAPI_OK;
}

_powercap_ppc_set_domain()

static int _powercap_ppc_set_domain ( hwd_control_state_t *  ctl, int  domain  )

static

Definition at line 340 of file linux-powercap-ppc.c.

{
    (void) ctl;
    if ( PAPI_DOM_ALL != domain )
        return PAPI_EINVAL;
 
    return PAPI_OK;
}

_powercap_ppc_shutdown_component()

static int _powercap_ppc_shutdown_component ( void  )

static

Definition at line 317 of file linux-powercap-ppc.c.

{
    int i;
    for( i = 0; i < num_events; i++ ) {
        close(event_fds[i]);
    }
 
    return PAPI_OK;
}

Here is the call graph for this function:

_powercap_ppc_shutdown_thread()

static int _powercap_ppc_shutdown_thread ( hwd_context_t *  ctx )

static

Definition at line 262 of file linux-powercap-ppc.c.

{
    (void) ctx;
    SUBDBG( "Enter _powercap_ppc_shutdown_thread\n" );
    return PAPI_OK;
}

_powercap_ppc_start()

static int _powercap_ppc_start ( hwd_context_t *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 241 of file linux-powercap-ppc.c.

{
    (void) ctx;
    (void) ctl;
 
    return PAPI_OK;
}

_powercap_ppc_stop()

static int _powercap_ppc_stop ( hwd_context_t *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 250 of file linux-powercap-ppc.c.

{
    (void) ctx;
    (void) ctl;
 
    return PAPI_OK;
}

_powercap_ppc_update_control_state()

static int _powercap_ppc_update_control_state ( hwd_control_state_t *  ctl, NativeInfo_t *  native, int  count, hwd_context_t *  ctx  )

static

Definition at line 217 of file linux-powercap-ppc.c.

{
    (void) ctx;
    int i, index;
 
    _powercap_ppc_control_state_t* control = ( _powercap_ppc_control_state_t* ) ctl;
    control->active_counters = count;
 
    for ( i = 0; i < count; ++i ) {
        index = native[i].ni_event;
        control->which_counter[i]=index;
        native[i].ni_position = i;
    }
 
    return PAPI_OK;
}

_powercap_ppc_write()

static int _powercap_ppc_write ( hwd_context_t *  ctx, hwd_control_state_t *  ctl, long long *  values  )

static

Definition at line 299 of file linux-powercap-ppc.c.

{
    (void) ctx;
    _powercap_ppc_control_state_t *control = ( _powercap_ppc_control_state_t * ) ctl;
 
    int i;
    for (i = 0; i < control->active_counters; i++) {
      if (PKG_CUR_POWER == powercap_ppc_ntv_events[control->which_counter[i]].type)
        write_powercap_value(control->which_counter[i], values[i]);
    }
 
    return PAPI_OK;
}

Here is the call graph for this function:

read_powercap_value()

static long long read_powercap_value ( int  index )

static

Definition at line 69 of file linux-powercap-ppc.c.

{
    int sz = pread(event_fds[index], read_buff, PAPI_MAX_STR_LEN, 0);
    read_buff[sz] = '\0';
 
    return atoll(read_buff);
}

Here is the caller graph for this function:

write_powercap_value()

static int write_powercap_value ( int  index, long long  value  )

static

Definition at line 78 of file linux-powercap-ppc.c.

{
    size_t ret = snprintf(write_buff, sizeof(write_buff), "%lld", value);
    if (ret <= 0 || sizeof(write_buff) <= ret)
        return PAPI_ENOSUPP;
 
    papi_powercap_ppc_lock();
    int sz = pwrite(event_fds[index], write_buff, PAPI_MAX_STR_LEN, 0);
    if ( sz == -1 ) {
        perror("Error in pwrite(): ");
    }
    papi_powercap_ppc_unlock();
 
    return 1;
}

Here is the caller graph for this function:

Variable Documentation

_powercap_ppc_vector

papi_vector_t _powercap_ppc_vector

Definition at line 52 of file linux-powercap-ppc.c.

event_fds

int event_fds[POWERCAP_MAX_COUNTERS]

static

Definition at line 50 of file linux-powercap-ppc.c.

num_events

int num_events =0

static

Definition at line 33 of file linux-powercap-ppc.c.

pkg_event_descs

const char* pkg_event_descs[PKG_NUM_EVENTS]

static

Initial value:

= {"Minimum value allowed for power capping.",
     "Maximum value allowed for power capping.",
     "Current power drawned by package."}

Definition at line 41 of file linux-powercap-ppc.c.

pkg_event_names

const char* pkg_event_names[PKG_NUM_EVENTS] = {"MIN_POWER", "MAX_POWER", "CURRENT_POWER"}

static

Definition at line 37 of file linux-powercap-ppc.c.

pkg_events

int pkg_events[PKG_NUM_EVENTS] = {PKG_MIN_POWER, PKG_MAX_POWER, PKG_CUR_POWER}

static

Definition at line 35 of file linux-powercap-ppc.c.

pkg_sys_flags

mode_t pkg_sys_flags[PKG_NUM_EVENTS] = {O_RDONLY, O_RDONLY, O_RDWR}

static

Definition at line 45 of file linux-powercap-ppc.c.

pkg_sys_names

const char* pkg_sys_names[PKG_NUM_EVENTS] = {"powercap-min", "powercap-max", "powercap-current"}

static

Definition at line 39 of file linux-powercap-ppc.c.

powercap_ppc_ntv_events

_powercap_ppc_native_event_entry_t powercap_ppc_ntv_events[(PKG_NUM_EVENTS)]

static

Definition at line 48 of file linux-powercap-ppc.c.

read_buff

char read_buff[PAPI_MAX_STR_LEN]

static

Definition at line 30 of file linux-powercap-ppc.c.

write_buff

char write_buff[PAPI_MAX_STR_LEN]

static

Definition at line 31 of file linux-powercap-ppc.c.