linux-powercap.c File Reference

powercap component More...

Include dependency graph for linux-powercap.c:

Go to the source code of this file.

Data Structures
struct	_powercap_register_t
struct	_powercap_native_event_entry_t
struct	_powercap_reg_alloc_t
struct	_powercap_control_state_t
struct	_powercap_context_t

Macros
#define	HANDLE_STRING_ERROR   {fprintf(stderr,"%s:%i unexpected string function error.\n",__FILE__,__LINE__); exit(-1);}
#define	PKG_ENERGY   0
#define	PKG_MAX_ENERGY_RANGE   1
#define	PKG_MAX_POWER_A   2
#define	PKG_POWER_LIMIT_A   3
#define	PKG_TIME_WINDOW_A   4
#define	PKG_MAX_POWER_B   5
#define	PKG_POWER_LIMIT_B   6
#define	PKG_TIME_WINDOW_B   7
#define	PKG_ENABLED   8
#define	PKG_NAME   9
#define	PKG_NUM_EVENTS   10
#define	COMPONENT_ENERGY   10
#define	COMPONENT_MAX_ENERGY_RANGE   11
#define	COMPONENT_MAX_POWER_A   12
#define	COMPONENT_POWER_LIMIT_A   13
#define	COMPONENT_TIME_WINDOW_A   14
#define	COMPONENT_ENABLED   15
#define	COMPONENT_NAME   16
#define	COMPONENT_NUM_EVENTS   7
#define	POWERCAP_MAX_COUNTERS   (2 * (PKG_NUM_EVENTS + (3 * COMPONENT_NUM_EVENTS)))

Functions
static long long	map_index_to_counter (hwd_control_state_t *ctl, int index)
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_init_thread (hwd_context_t *ctx)
static int	_powercap_init_component (int cidx)
static int	_powercap_init_control_state (hwd_control_state_t *ctl)
static int	_powercap_start (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_powercap_stop (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_powercap_shutdown_thread (hwd_context_t *ctx)
static int	_powercap_read (hwd_context_t *ctx, hwd_control_state_t *ctl, long long **events, int flags)
static int	_powercap_write (hwd_context_t *ctx, hwd_control_state_t *ctl, long long *values)
static int	_powercap_shutdown_component (void)
static int	_powercap_ctl (hwd_context_t *ctx, int code, _papi_int_option_t *option)
static int	_powercap_update_control_state (hwd_control_state_t *ctl, NativeInfo_t *native, int count, hwd_context_t *ctx)
static int	_powercap_set_domain (hwd_control_state_t *ctl, int domain)
static int	_powercap_reset (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_powercap_ntv_enum_events (unsigned int *EventCode, int modifier)
static int	_powercap_ntv_code_to_name (unsigned int EventCode, char *name, int len)
static int	_powercap_ntv_code_to_descr (unsigned int EventCode, char *name, int len)
static int	_powercap_ntv_code_to_info (unsigned int EventCode, PAPI_event_info_t *info)

Variables
static char	read_buff [PAPI_MAX_STR_LEN]
static char	write_buff [PAPI_MAX_STR_LEN]
static long long	max_pkg_energy_count
static long long	max_component_energy_count
static int	num_events =0
static int	pkg_events [PKG_NUM_EVENTS] = {PKG_ENERGY, PKG_MAX_ENERGY_RANGE, PKG_MAX_POWER_A, PKG_POWER_LIMIT_A, PKG_TIME_WINDOW_A, PKG_MAX_POWER_B, PKG_POWER_LIMIT_B, PKG_TIME_WINDOW_B, PKG_ENABLED, PKG_NAME}
static char *	pkg_event_names [PKG_NUM_EVENTS] = {"ENERGY_UJ", "MAX_ENERGY_RANGE_UJ", "MAX_POWER_A_UW", "POWER_LIMIT_A_UW", "TIME_WINDOW_A_US", "MAX_POWER_B_UW", "POWER_LIMIT_B_UW", "TIME_WINDOW_B", "ENABLED", "NAME"}
static char *	pkg_sys_names [PKG_NUM_EVENTS] = {"energy_uj", "max_energy_range_uj", "constraint_0_max_power_uw", "constraint_0_power_limit_uw", "constraint_0_time_window_us", "constraint_1_max_power_uw", "constraint_1_power_limit_uw", "constraint_1_time_window_us", "enabled", "name"}
static mode_t	pkg_sys_flags [PKG_NUM_EVENTS] = {O_RDONLY, O_RDONLY, O_RDONLY, O_RDWR, O_RDONLY, O_RDONLY, O_RDWR, O_RDONLY, O_RDONLY, O_RDONLY}
static int	component_events [COMPONENT_NUM_EVENTS] = {COMPONENT_ENERGY, COMPONENT_MAX_ENERGY_RANGE, COMPONENT_MAX_POWER_A, COMPONENT_POWER_LIMIT_A, COMPONENT_TIME_WINDOW_A, COMPONENT_ENABLED, COMPONENT_NAME}
static char *	component_event_names [COMPONENT_NUM_EVENTS] = {"ENERGY_UJ", "MAX_ENERGY_RANGE_UJ", "MAX_POWER_A_UW", "POWER_LIMIT_A_UW", "TIME_WINDOW_A_US", "ENABLED", "NAME"}
static char *	component_sys_names [COMPONENT_NUM_EVENTS] = {"energy_uj", "max_energy_range_uj", "constraint_0_max_power_uw", "constraint_0_power_limit_uw", "constraint_0_time_window_us", "enabled", "name"}
static mode_t	component_sys_flags [COMPONENT_NUM_EVENTS] = {O_RDONLY, O_RDONLY, O_RDONLY, O_RDWR, O_RDONLY, O_RDONLY, O_RDONLY}
static _powercap_native_event_entry_t	powercap_ntv_events [(2 *(PKG_NUM_EVENTS+(3 *COMPONENT_NUM_EVENTS)))]
static int	event_fds [POWERCAP_MAX_COUNTERS]
papi_vector_t	_powercap_vector

Detailed Description

Author

Philip Vaccaro

To work, the powercap kernel module must be loaded.

Author

PAPI team UTK/ICL

To work, the powercap kernel module must be loaded.

Definition in file linux-powercap.c.

Macro Definition Documentation

COMPONENT_ENABLED

#define COMPONENT_ENABLED   15

Definition at line 85 of file linux-powercap.c.

COMPONENT_ENERGY

#define COMPONENT_ENERGY   10

Definition at line 80 of file linux-powercap.c.

COMPONENT_MAX_ENERGY_RANGE

#define COMPONENT_MAX_ENERGY_RANGE   11

Definition at line 81 of file linux-powercap.c.

COMPONENT_MAX_POWER_A

#define COMPONENT_MAX_POWER_A   12

Definition at line 82 of file linux-powercap.c.

COMPONENT_NAME

#define COMPONENT_NAME   16

Definition at line 86 of file linux-powercap.c.

COMPONENT_NUM_EVENTS

#define COMPONENT_NUM_EVENTS   7

Definition at line 88 of file linux-powercap.c.

COMPONENT_POWER_LIMIT_A

#define COMPONENT_POWER_LIMIT_A   13

Definition at line 83 of file linux-powercap.c.

COMPONENT_TIME_WINDOW_A

#define COMPONENT_TIME_WINDOW_A   14

Definition at line 84 of file linux-powercap.c.

HANDLE_STRING_ERROR

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

Definition at line 29 of file linux-powercap.c.

PKG_ENABLED

#define PKG_ENABLED   8

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

PKG_ENERGY

#define PKG_ENERGY   0

Definition at line 61 of file linux-powercap.c.

PKG_MAX_ENERGY_RANGE

#define PKG_MAX_ENERGY_RANGE   1

Definition at line 62 of file linux-powercap.c.

PKG_MAX_POWER_A

#define PKG_MAX_POWER_A   2

Definition at line 63 of file linux-powercap.c.

PKG_MAX_POWER_B

#define PKG_MAX_POWER_B   5

Definition at line 66 of file linux-powercap.c.

PKG_NAME

#define PKG_NAME   9

Definition at line 70 of file linux-powercap.c.

PKG_NUM_EVENTS

#define PKG_NUM_EVENTS   10

Definition at line 72 of file linux-powercap.c.

PKG_POWER_LIMIT_A

#define PKG_POWER_LIMIT_A   3

Definition at line 64 of file linux-powercap.c.

PKG_POWER_LIMIT_B

#define PKG_POWER_LIMIT_B   6

Definition at line 67 of file linux-powercap.c.

PKG_TIME_WINDOW_A

#define PKG_TIME_WINDOW_A   4

Definition at line 65 of file linux-powercap.c.

PKG_TIME_WINDOW_B

#define PKG_TIME_WINDOW_B   7

Definition at line 68 of file linux-powercap.c.

POWERCAP_MAX_COUNTERS

#define POWERCAP_MAX_COUNTERS   (2 * (PKG_NUM_EVENTS + (3 * COMPONENT_NUM_EVENTS)))

Definition at line 94 of file linux-powercap.c.

Function Documentation

_local_strlcpy()

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

static

Definition at line 127 of file linux-powercap.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_ctl()

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

static

Definition at line 488 of file linux-powercap.c.

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

_powercap_init_component()

static int _powercap_init_component ( int  cidx )

static

Definition at line 166 of file linux-powercap.c.

{
    int retval = PAPI_OK;
  int num_sockets = -1;
  int s = -1, e = -1, c = -1;
  long unsigned int strErr;
 
  char events_dir[128];
  char event_path[128];
  char *strCpy;
 
  DIR *events;
 
  // get hw info
  const PAPI_hw_info_t *hw_info;
  hw_info=&( _papi_hwi_system_info.hw_info );
 
  // check if intel processor
  if ( hw_info->vendor!=PAPI_VENDOR_INTEL ) {
    strCpy=strncpy(_powercap_vector.cmp_info.disabled_reason, "Not an Intel processor", PAPI_MAX_STR_LEN);
    if (strCpy == NULL) HANDLE_STRING_ERROR;
    retval = PAPI_ENOSUPP;
    goto fn_fail;
  }
 
  // store number of sockets for adding events
  num_sockets = hw_info->sockets;
 
  num_events = 0;
  for(s = 0; s < num_sockets; s++) {
 
    // Find the directory corresponding to the socket number.  There may be other top-level entries in there
    // besides packages, such as "psys", that mess up the numbering, so we conduct an exhaustive search.
    int s_dir, found = 0;
    for(s_dir = 0; ; s_dir++) {
      strErr=snprintf(event_path, sizeof(event_path), "/sys/class/powercap/intel-rapl:%d/%s", s_dir, pkg_sys_names[PKG_NAME]);
      event_path[sizeof(event_path)-1]=0;
      if (strErr > sizeof(event_path)) HANDLE_STRING_ERROR;
 
      int event_fd;
      event_fd = open(event_path, pkg_sys_flags[PKG_NAME]);
      if (event_fd == -1) { break; }
 
      int sz = pread(event_fd, read_buff, PAPI_MAX_STR_LEN, 0);
      read_buff[sz] = '\0';
      close(event_fd);
 
      if (strncmp(read_buff, "package-", strlen("package-")) == 0 && strtol(read_buff + strlen("package-"), NULL, 10) == s) {
        found = 1;
    break;
      }
    }
    if (!found) { continue; }
 
    // compose string of a pkg directory path
    strErr=snprintf(events_dir, sizeof(events_dir), "/sys/class/powercap/intel-rapl:%d/", s_dir);
    events_dir[sizeof(events_dir)-1]=0;
    if (strErr > sizeof(events_dir)) HANDLE_STRING_ERROR;
 
    // open directory to make sure it exists
    events = opendir(events_dir);
 
    // not a valid pkg/component directory so continue
    if (events == NULL) { continue; }
    closedir(events);                                                // opendir has mallocs; so clean up.
 
    // loop through pkg events and create powercap event entries
    for (e = 0; e < PKG_NUM_EVENTS; e++) {
 
      // compose string to individual event
      strErr=snprintf(event_path, sizeof(event_path), "%s%s", events_dir, pkg_sys_names[e]);
      event_path[sizeof(event_path)-1]=0;
      if (strErr > sizeof(event_path)) HANDLE_STRING_ERROR;
      // not a valid pkg event path so continue
 
      if (access(event_path, R_OK) == -1) { continue; }
 
      strErr=snprintf(powercap_ntv_events[num_events].name, sizeof(powercap_ntv_events[num_events].name), "%s:ZONE%d", pkg_event_names[e], s);
      powercap_ntv_events[num_events].name[sizeof(powercap_ntv_events[num_events].name)-1]=0;
      if (strErr > sizeof(powercap_ntv_events[num_events].name)) HANDLE_STRING_ERROR;
      //snprintf(powercap_ntv_events[num_events].description, sizeof(powercap_ntv_events[num_events].name), "%s:ZONE%d", pkg_event_names[e], s);
      //snprintf(powercap_ntv_events[num_events].units, sizeof(powercap_ntv_events[num_events].name), "%s:ZONE%d", pkg_event_names[e], s);
      powercap_ntv_events[num_events].return_type = PAPI_DATATYPE_UINT64;
      powercap_ntv_events[num_events].type = pkg_events[e];
 
      powercap_ntv_events[num_events].resources.selector = num_events + 1;
 
      event_fds[num_events] = open(event_path, O_SYNC|pkg_sys_flags[e]);
 
      if(powercap_ntv_events[num_events].type == PKG_NAME) {
        int sz = pread(event_fds[num_events], read_buff, PAPI_MAX_STR_LEN, 0);
        read_buff[sz] = '\0';
        strErr=snprintf(powercap_ntv_events[num_events].description, sizeof(powercap_ntv_events[num_events].description), "%s", read_buff);
        powercap_ntv_events[num_events].description[sizeof(powercap_ntv_events[num_events].description)-1]=0;
        if (strErr > sizeof(powercap_ntv_events[num_events].description)) HANDLE_STRING_ERROR;
      }
 
      if(powercap_ntv_events[num_events].type == PKG_MAX_ENERGY_RANGE) {
        int sz = pread(event_fds[num_events], read_buff, PAPI_MAX_STR_LEN, 0);
        read_buff[sz] = '\0';
        max_pkg_energy_count = atoll(read_buff);
      }
 
      num_events++;
    }
 
    // reset component count for each socket
    c = 0;
    strErr=snprintf(events_dir, sizeof(events_dir), "/sys/class/powercap/intel-rapl:%d:%d/", s_dir, c);
    events_dir[sizeof(events_dir)-1]=0;
    if (strErr > sizeof(events_dir)) HANDLE_STRING_ERROR;
    while((events = opendir(events_dir)) != NULL) {
      closedir(events);                                                // opendir has mallocs; so clean up.
 
      // loop through pkg events and create powercap event entries
      for (e = 0; e < COMPONENT_NUM_EVENTS; e++) {
 
        // compose string to individual event
        strErr=snprintf(event_path, sizeof(event_path), "%s%s", events_dir, component_sys_names[e]);
        event_path[sizeof(event_path)-1]=0;
        if (strErr > sizeof(event_path)) HANDLE_STRING_ERROR;
 
        // not a valid pkg event path so continue
        if (access(event_path, R_OK) == -1) { continue; }
 
        strErr=snprintf(powercap_ntv_events[num_events].name, sizeof(powercap_ntv_events[num_events].name), "%s:ZONE%d_SUBZONE%d", component_event_names[e], s, c);
        powercap_ntv_events[num_events].name[sizeof(powercap_ntv_events[num_events].name)-1]=0;
        if (strErr > sizeof(powercap_ntv_events[num_events].name)) HANDLE_STRING_ERROR;
        //snprintf(powercap_ntv_events[num_events].description, sizeof(powercap_ntv_events[num_events].name), "%s:ZONE%d_SUBZONE%d", component_event_names[e], s, c);
        //snprintf(powercap_ntv_events[num_events].units, sizeof(powercap_ntv_events[num_events].name), "%s:ZONE%d_SUBZONE%d", component_event_names[e], s, c);
        powercap_ntv_events[num_events].return_type = PAPI_DATATYPE_UINT64;
        powercap_ntv_events[num_events].type = component_events[e];
 
        powercap_ntv_events[num_events].resources.selector = num_events + 1;
 
        event_fds[num_events] = open(event_path, O_SYNC|component_sys_flags[e]);
 
        if(powercap_ntv_events[num_events].type == COMPONENT_NAME) {
          int sz = pread(event_fds[num_events], read_buff, PAPI_MAX_STR_LEN, 0);
          read_buff[sz] = '\0';
          strErr=snprintf(powercap_ntv_events[num_events].description, sizeof(powercap_ntv_events[num_events].description), "%s", read_buff);
          powercap_ntv_events[num_events].description[sizeof(powercap_ntv_events[num_events].description)-1]=0;
          if (strErr > sizeof(powercap_ntv_events[num_events].description)) HANDLE_STRING_ERROR;
        }
 
        if(powercap_ntv_events[num_events].type == COMPONENT_MAX_ENERGY_RANGE) {
          int sz = pread(event_fds[num_events], read_buff, PAPI_MAX_STR_LEN, 0);
          read_buff[sz] = '\0';
          max_component_energy_count = atoll(read_buff);
        }
 
        num_events++;
      }
 
      // test for next component
      c++;
 
      // compose string of an pkg directory path
      strErr=snprintf(events_dir, sizeof(events_dir), "/sys/class/powercap/intel-rapl:%d:%d/", s_dir, c);
      events_dir[sizeof(events_dir)-1]=0;
      if (strErr > sizeof(events_dir)) HANDLE_STRING_ERROR;
    }
  }
 
  /* Export the total number of events available */
  _powercap_vector.cmp_info.num_native_events = num_events;
  _powercap_vector.cmp_info.num_cntrs = num_events;
  _powercap_vector.cmp_info.num_mpx_cntrs = num_events;
 
  /* Export the component id */
  _powercap_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_init_control_state()

static int _powercap_init_control_state ( hwd_control_state_t *  ctl )

static

Definition at line 350 of file linux-powercap.c.

{
    _powercap_control_state_t* control = ( _powercap_control_state_t* ) ctl;
    memset( control, 0, sizeof ( _powercap_control_state_t ) );
 
 
    /* if an event is a counter, set its corresponding flag to 1  */
    int i;
    for (i = 0; i < num_events; i++) {
        if ((powercap_ntv_events[i].type == PKG_ENERGY) || (powercap_ntv_events[i].type == COMPONENT_ENERGY)) {
            control->need_difference[i] = 1;
        }
    }
 
    return PAPI_OK;
}

_powercap_init_thread()

static int _powercap_init_thread ( hwd_context_t *  ctx )

static

Definition at line 157 of file linux-powercap.c.

{
    ( void ) ctx;
    return PAPI_OK;
}

_powercap_ntv_code_to_descr()

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

static

Definition at line 578 of file linux-powercap.c.

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

Here is the call graph for this function:

_powercap_ntv_code_to_info()

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

static

Definition at line 588 of file linux-powercap.c.

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

Here is the call graph for this function:

_powercap_ntv_code_to_name()

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

static

Definition at line 564 of file linux-powercap.c.

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

Here is the call graph for this function:

_powercap_ntv_enum_events()

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

static

Definition at line 541 of file linux-powercap.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_read()

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

static

Definition at line 398 of file linux-powercap.c.

{
  SUBDBG("Enter _powercap_read\n");
 
  (void) flags;
  _powercap_control_state_t* control = ( _powercap_control_state_t* ) ctl;
  _powercap_context_t* context = ( _powercap_context_t* ) ctx;
 
  long long start_val = 0;
  long long curr_val = 0;
  int c, i;
 
  for( c = 0; c < control->active_counters; c++ ) {
    i = map_index_to_counter(ctl, c);
    start_val = context->start_value[i];
    curr_val = read_powercap_value(i);
 
    SUBDBG("%d, start value: %lld, current value %lld\n", i, start_val, curr_val);
 
    if(start_val) {
 
      /* Make sure an event is a counter. */
      if (control->need_difference[i] == 1) {
 
        /* Wraparound. */
        if(start_val > curr_val) {
          SUBDBG("Wraparound!\nstart value:\t%lld,\tcurrent value:%lld\n", start_val, curr_val);
          if( powercap_ntv_events[i].type == PKG_ENERGY ) {
            curr_val += (max_pkg_energy_count - start_val);
          } else if( powercap_ntv_events[i].type == COMPONENT_ENERGY ) {
            curr_val += (max_component_energy_count - start_val);
          } else {
            curr_val += (0x100000000 - start_val);
          }
        }
 
        /* Normal subtraction. */
        else if (start_val < curr_val) {
          SUBDBG("Normal subtraction!\nstart value:\t%lld,\tcurrent value:%lld\n", start_val, curr_val);
          curr_val -= start_val;
        }
        SUBDBG("Final value: %lld\n", curr_val);
 
      }
    }
    control->count[c]=curr_val;
  }
 
  *events = ( ( _powercap_control_state_t* ) ctl )->count;
 
  return PAPI_OK;
}

Here is the call graph for this function:

_powercap_reset()

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

static

Definition at line 531 of file linux-powercap.c.

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

_powercap_set_domain()

static int _powercap_set_domain ( hwd_control_state_t *  ctl, int  domain  )

static

Definition at line 521 of file linux-powercap.c.

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

_powercap_shutdown_component()

static int _powercap_shutdown_component ( void  )

static

Definition at line 472 of file linux-powercap.c.

{
  int i;
 
  /* Read counters into expected slot */
  for(i=0;i<num_events;i++) {
    close(event_fds[i]);
  }
    return PAPI_OK;
}

Here is the call graph for this function:

_powercap_shutdown_thread()

static int _powercap_shutdown_thread ( hwd_context_t *  ctx )

static

Definition at line 389 of file linux-powercap.c.

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

_powercap_start()

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

static

Definition at line 367 of file linux-powercap.c.

{
    _powercap_context_t* context = ( _powercap_context_t* ) ctx;
    (void) ctl;
 
    int b;
    for( b = 0; b < num_events; b++ ) {
      context->start_value[b]=read_powercap_value(b);
    }
 
    return PAPI_OK;
}

Here is the call graph for this function:

_powercap_stop()

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

static

Definition at line 380 of file linux-powercap.c.

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

_powercap_update_control_state()

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

static

Definition at line 499 of file linux-powercap.c.

{
  (void) ctx;
  int i, index;
 
  _powercap_control_state_t* control = ( _powercap_control_state_t* ) ctl;
  control->active_counters = count;
 
  if (count==0) return PAPI_OK;
 
  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_write()

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

static

Definition at line 452 of file linux-powercap.c.

{
    /* write values */
    ( void ) ctx;
    _powercap_control_state_t *control = ( _powercap_control_state_t * ) ctl;
 
    int c, i;
 
    for(c=0;c<control->active_counters;c++) {
      i = map_index_to_counter(ctl, c);
      if( (powercap_ntv_events[i].type == PKG_POWER_LIMIT_A) || (powercap_ntv_events[i].type == PKG_POWER_LIMIT_B) ) {
        write_powercap_value(i, values[c]);
      }
    }
 
    return PAPI_OK;
}

Here is the call graph for this function:

map_index_to_counter()

static long long map_index_to_counter ( hwd_control_state_t *  ctl, int  index  )

static

Definition at line 119 of file linux-powercap.c.

{
  _powercap_control_state_t* control = ( _powercap_control_state_t* ) ctl;
 
  return control->which_counter[index];
}

Here is the caller graph for this function:

read_powercap_value()

static long long read_powercap_value ( int  index )

static

Definition at line 134 of file linux-powercap.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 142 of file linux-powercap.c.

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

Here is the caller graph for this function:

Variable Documentation

_powercap_vector

papi_vector_t _powercap_vector

Definition at line 113 of file linux-powercap.c.

component_event_names

char* component_event_names[COMPONENT_NUM_EVENTS] = {"ENERGY_UJ", "MAX_ENERGY_RANGE_UJ", "MAX_POWER_A_UW", "POWER_LIMIT_A_UW", "TIME_WINDOW_A_US", "ENABLED", "NAME"}

static

Definition at line 90 of file linux-powercap.c.

component_events

int component_events[COMPONENT_NUM_EVENTS] = {COMPONENT_ENERGY, COMPONENT_MAX_ENERGY_RANGE, COMPONENT_MAX_POWER_A, COMPONENT_POWER_LIMIT_A, COMPONENT_TIME_WINDOW_A, COMPONENT_ENABLED, COMPONENT_NAME}

static

Definition at line 89 of file linux-powercap.c.

component_sys_flags

mode_t component_sys_flags[COMPONENT_NUM_EVENTS] = {O_RDONLY, O_RDONLY, O_RDONLY, O_RDWR, O_RDONLY, O_RDONLY, O_RDONLY}

static

Definition at line 92 of file linux-powercap.c.

component_sys_names

char* component_sys_names[COMPONENT_NUM_EVENTS] = {"energy_uj", "max_energy_range_uj", "constraint_0_max_power_uw", "constraint_0_power_limit_uw", "constraint_0_time_window_us", "enabled", "name"}

static

Definition at line 91 of file linux-powercap.c.

event_fds

int event_fds[POWERCAP_MAX_COUNTERS]

static

Definition at line 98 of file linux-powercap.c.

max_component_energy_count

long long max_component_energy_count

static

Definition at line 56 of file linux-powercap.c.

max_pkg_energy_count

long long max_pkg_energy_count

static

Definition at line 55 of file linux-powercap.c.

num_events

int num_events =0

static

Definition at line 58 of file linux-powercap.c.

pkg_event_names

char* pkg_event_names[PKG_NUM_EVENTS] = {"ENERGY_UJ", "MAX_ENERGY_RANGE_UJ", "MAX_POWER_A_UW", "POWER_LIMIT_A_UW", "TIME_WINDOW_A_US", "MAX_POWER_B_UW", "POWER_LIMIT_B_UW", "TIME_WINDOW_B", "ENABLED", "NAME"}

static

Definition at line 74 of file linux-powercap.c.

pkg_events

int pkg_events[PKG_NUM_EVENTS] = {PKG_ENERGY, PKG_MAX_ENERGY_RANGE, PKG_MAX_POWER_A, PKG_POWER_LIMIT_A, PKG_TIME_WINDOW_A, PKG_MAX_POWER_B, PKG_POWER_LIMIT_B, PKG_TIME_WINDOW_B, PKG_ENABLED, PKG_NAME}

static

Definition at line 73 of file linux-powercap.c.

pkg_sys_flags

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

static

Definition at line 76 of file linux-powercap.c.

pkg_sys_names

char* pkg_sys_names[PKG_NUM_EVENTS] = {"energy_uj", "max_energy_range_uj", "constraint_0_max_power_uw", "constraint_0_power_limit_uw", "constraint_0_time_window_us", "constraint_1_max_power_uw", "constraint_1_power_limit_uw", "constraint_1_time_window_us", "enabled", "name"}

static

Definition at line 75 of file linux-powercap.c.

powercap_ntv_events

_powercap_native_event_entry_t powercap_ntv_events[(2 *(PKG_NUM_EVENTS+(3 *COMPONENT_NUM_EVENTS)))]

static

Definition at line 96 of file linux-powercap.c.

read_buff

char read_buff[PAPI_MAX_STR_LEN]

static

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

write_buff

char write_buff[PAPI_MAX_STR_LEN]

static

Definition at line 53 of file linux-powercap.c.