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	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 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 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.

Definition in file linux-powercap.c.

Macro Definition Documentation

COMPONENT_ENABLED

#define COMPONENT_ENABLED   15

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

COMPONENT_ENERGY

#define COMPONENT_ENERGY   10

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

COMPONENT_MAX_ENERGY_RANGE

#define COMPONENT_MAX_ENERGY_RANGE   11

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

COMPONENT_MAX_POWER_A

#define COMPONENT_MAX_POWER_A   12

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

COMPONENT_NAME

#define COMPONENT_NAME   16

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

COMPONENT_NUM_EVENTS

#define COMPONENT_NUM_EVENTS   7

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

COMPONENT_POWER_LIMIT_A

#define COMPONENT_POWER_LIMIT_A   13

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

COMPONENT_TIME_WINDOW_A

#define COMPONENT_TIME_WINDOW_A   14

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

PKG_ENABLED

#define PKG_ENABLED   8

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

PKG_ENERGY

#define PKG_ENERGY   0

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

PKG_MAX_ENERGY_RANGE

#define PKG_MAX_ENERGY_RANGE   1

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

PKG_MAX_POWER_A

#define PKG_MAX_POWER_A   2

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

PKG_MAX_POWER_B

#define PKG_MAX_POWER_B   5

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

PKG_NAME

#define PKG_NAME   9

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

PKG_NUM_EVENTS

#define PKG_NUM_EVENTS   10

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

PKG_POWER_LIMIT_A

#define PKG_POWER_LIMIT_A   3

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

PKG_POWER_LIMIT_B

#define PKG_POWER_LIMIT_B   6

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

PKG_TIME_WINDOW_A

#define PKG_TIME_WINDOW_A   4

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

PKG_TIME_WINDOW_B

#define PKG_TIME_WINDOW_B   7

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

POWERCAP_MAX_COUNTERS

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

Definition at line 88 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 113 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 403 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 152 of file linux-powercap.c.

{

  int num_sockets = -1;
  int s = -1, e = -1, c = -1;

  char events_dir[128];
  char event_path[128];

  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 ) {
    strncpy(_powercap_vector.cmp_info.disabled_reason, "Not an Intel processor", PAPI_MAX_STR_LEN);
    return PAPI_ENOSUPP;
  }

  // store number of sockets for adding events
  num_sockets = hw_info->sockets;

  num_events = 0;
  for(s = 0; s < num_sockets; s++) {

    // compose string of a pkg directory path
    snprintf(events_dir, sizeof(events_dir), "/sys/class/powercap/intel-rapl:%d/", s);

    // 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
      snprintf(event_path, sizeof(event_path), "%s%s", events_dir, pkg_sys_names[e]);
      // not a valid pkg event path so continue
      if (access(event_path, F_OK) == -1) { continue; }

      snprintf(powercap_ntv_events[num_events].name, sizeof(powercap_ntv_events[num_events].name), "%s:ZONE%d", pkg_event_names[e], s);
      //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';
        snprintf(powercap_ntv_events[num_events].description, sizeof(powercap_ntv_events[num_events].description), "%s", read_buff);
      }

      num_events++;
    }

    // reset component count for each socket
    c = 0;
    snprintf(events_dir, sizeof(events_dir), "/sys/class/powercap/intel-rapl:%d:%d/", s, c);
    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
        snprintf(event_path, sizeof(event_path), "%s%s", events_dir, component_sys_names[e]);

        // not a valid pkg event path so continue
        if (access(event_path, F_OK) == -1) { continue; }

        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);
        //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';
          snprintf(powercap_ntv_events[num_events].description, sizeof(powercap_ntv_events[num_events].description), "%s", read_buff);
        }

        num_events++;
      }

      // test for next component
      c++;

      // compose string of an pkg directory path
      snprintf(events_dir, sizeof(events_dir), "/sys/class/powercap/intel-rapl:%d:%d/", s, c);
    }
  }

  /* 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;

  return PAPI_OK;
}

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 274 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 143 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 491 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 501 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, sizeof( info->symbol ));
    _local_strlcpy( info->long_descr, powercap_ntv_events[index].description, sizeof( info->long_descr ) );
    _local_strlcpy( info->units, powercap_ntv_events[index].units, sizeof( info->units ) );

    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 477 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 454 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 322 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;

  for( c = 0; c < num_events; c++ ) {
    start_val = context->start_value[c];
    curr_val = read_powercap_value(c);

    SUBDBG("%d, start value: %lld, current value %lld\n", c, start_val, curr_val);

    if(start_val) {

      /* Make sure an event is a counter. */
      if (control->need_difference[c] == 1) {

    /* Wraparound. */
    if(start_val > curr_val) {
      SUBDBG("Wraparound!\nstart value:\t%lld,\tcurrent value:%lld\n", start_val, curr_val);
      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 444 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 434 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 387 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 313 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 291 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 304 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 414 of file linux-powercap.c.

{
  (void) ctx;
  int i, index;

  _powercap_control_state_t* control = ( _powercap_control_state_t* ) ctl;
  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 368 of file linux-powercap.c.

{
    /* write values */
    ( void ) ctx;
    _powercap_control_state_t *control = ( _powercap_control_state_t * ) ctl;

    int i;

    for(i=0;i<num_events;i++) {
      if( (powercap_ntv_events[control->which_counter[i]].type == PKG_POWER_LIMIT_A) || (powercap_ntv_events[control->which_counter[i]].type == PKG_POWER_LIMIT_B) ) {
        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 120 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 128 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 106 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 84 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 83 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 86 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 85 of file linux-powercap.c.

event_fds

int event_fds[POWERCAP_MAX_COUNTERS]

static

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

num_events

int num_events =0

static

Definition at line 52 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 68 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 67 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 70 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 69 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 90 of file linux-powercap.c.

read_buff

char read_buff[PAPI_MAX_STR_LEN]

static

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

write_buff

char write_buff[PAPI_MAX_STR_LEN]

static

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