linux-rapl.c File Reference

rapl component More...

Include dependency graph for linux-rapl.c:

Go to the source code of this file.

Data Structures
struct	_rapl_register_t
struct	_rapl_native_event_entry_t
struct	_rapl_reg_alloc_t
struct	_rapl_control_state_t
struct	_rapl_context_t
struct	fd_array_t

Macros
#define	MSR_AMD_RAPL_POWER_UNIT   0xc0010299
#define	MSR_AMD_PKG_ENERGY_STATUS   0xc001029B
#define	MSR_AMD_PP0_ENERGY_STATUS   0xc001029A
#define	MSR_INTEL_RAPL_POWER_UNIT   0x606
#define	MSR_PKG_RAPL_POWER_LIMIT   0x610
#define	MSR_INTEL_PKG_ENERGY_STATUS   0x611
#define	MSR_PKG_PERF_STATUS   0x613
#define	MSR_PKG_POWER_INFO   0x614
#define	MSR_PP0_POWER_LIMIT   0x638
#define	MSR_INTEL_PP0_ENERGY_STATUS   0x639
#define	MSR_PP0_POLICY   0x63A
#define	MSR_PP0_PERF_STATUS   0x63B
#define	MSR_PP1_POWER_LIMIT   0x640
#define	MSR_PP1_ENERGY_STATUS   0x641
#define	MSR_PP1_POLICY   0x642
#define	MSR_DRAM_POWER_LIMIT   0x618
#define	MSR_DRAM_ENERGY_STATUS   0x619
#define	MSR_DRAM_PERF_STATUS   0x61B
#define	MSR_DRAM_POWER_INFO   0x61C
#define	MSR_PLATFORM_ENERGY_STATUS   0x64d
#define	POWER_UNIT_OFFSET   0
#define	POWER_UNIT_MASK   0x0f
#define	ENERGY_UNIT_OFFSET   0x08
#define	ENERGY_UNIT_MASK   0x1f
#define	TIME_UNIT_OFFSET   0x10
#define	TIME_UNIT_MASK   0x0f
#define	POWER_INFO_UNIT_MASK   0x7fff
#define	THERMAL_SHIFT   0
#define	MINIMUM_POWER_SHIFT   16
#define	MAXIMUM_POWER_SHIFT   32
#define	MAXIMUM_TIME_WINDOW_SHIFT   48
#define	RAPL_MAX_COUNTERS   64
#define	PACKAGE_ENERGY   0
#define	PACKAGE_THERMAL   1
#define	PACKAGE_MINIMUM   2
#define	PACKAGE_MAXIMUM   3
#define	PACKAGE_TIME_WINDOW   4
#define	PACKAGE_ENERGY_CNT   5
#define	PACKAGE_THERMAL_CNT   6
#define	PACKAGE_MINIMUM_CNT   7
#define	PACKAGE_MAXIMUM_CNT   8
#define	PACKAGE_TIME_WINDOW_CNT   9
#define	DRAM_ENERGY   10
#define	PLATFORM_ENERGY   11

Functions
static long long	read_msr (int fd, unsigned int which)
static int	open_fd (int offset)
static long long	read_rapl_value (int index)
static long long	convert_rapl_energy (int index, long long value)
static int	get_kernel_nr_cpus (void)
static int	_rapl_init_thread (hwd_context_t *ctx)
static int	_rapl_init_component (int cidx)
static int	_rapl_init_control_state (hwd_control_state_t *ctl)
static int	_rapl_start (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_rapl_stop (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_rapl_shutdown_thread (hwd_context_t *ctx)
int	_rapl_read (hwd_context_t *ctx, hwd_control_state_t *ctl, long long **events, int flags)
static int	_rapl_shutdown_component (void)
static int	_rapl_ctl (hwd_context_t *ctx, int code, _papi_int_option_t *option)
static int	_rapl_update_control_state (hwd_control_state_t *ctl, NativeInfo_t *native, int count, hwd_context_t *ctx)
static int	_rapl_set_domain (hwd_control_state_t *ctl, int domain)
static int	_rapl_reset (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_rapl_ntv_enum_events (unsigned int *EventCode, int modifier)
static int	_rapl_ntv_code_to_name (unsigned int EventCode, char *name, int len)
static int	_rapl_ntv_code_to_descr (unsigned int EventCode, char *name, int len)
static int	_rapl_ntv_code_to_info (unsigned int EventCode, PAPI_event_info_t *info)

Variables
papi_vector_t	_rapl_vector
static _rapl_native_event_entry_t *	rapl_native_events =NULL
static int	num_events = 0
struct fd_array_t *	fd_array =NULL
static int	num_packages =0
static int	num_cpus =0
int	power_divisor
int	time_divisor
int	cpu_energy_divisor
int	dram_energy_divisor
unsigned int	msr_rapl_power_unit

Detailed Description

Author

Vince Weaver

This component enables RAPL (Running Average Power Level) energy measurements on Intel SandyBridge/IvyBridge/Haswell

To work, either msr_safe kernel module from LLNL (https://github.com/scalability-llnl/msr-safe), or the x86 generic MSR driver must be installed (CONFIG_X86_MSR) and the /dev/cpu/?/<msr_safe | msr> files must have read permissions

Definition in file linux-rapl.c.

Macro Definition Documentation

DRAM_ENERGY

#define DRAM_ENERGY   10

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

ENERGY_UNIT_MASK

#define ENERGY_UNIT_MASK   0x1f

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

ENERGY_UNIT_OFFSET

#define ENERGY_UNIT_OFFSET   0x08

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

MAXIMUM_POWER_SHIFT

#define MAXIMUM_POWER_SHIFT   32

Definition at line 95 of file linux-rapl.c.

MAXIMUM_TIME_WINDOW_SHIFT

#define MAXIMUM_TIME_WINDOW_SHIFT   48

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

MINIMUM_POWER_SHIFT

#define MINIMUM_POWER_SHIFT   16

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

MSR_AMD_PKG_ENERGY_STATUS

#define MSR_AMD_PKG_ENERGY_STATUS   0xc001029B

Definition at line 38 of file linux-rapl.c.

MSR_AMD_PP0_ENERGY_STATUS

#define MSR_AMD_PP0_ENERGY_STATUS   0xc001029A

Definition at line 39 of file linux-rapl.c.

MSR_AMD_RAPL_POWER_UNIT

#define MSR_AMD_RAPL_POWER_UNIT   0xc0010299

Definition at line 36 of file linux-rapl.c.

MSR_DRAM_ENERGY_STATUS

#define MSR_DRAM_ENERGY_STATUS   0x619

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

MSR_DRAM_PERF_STATUS

#define MSR_DRAM_PERF_STATUS   0x61B

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

MSR_DRAM_POWER_INFO

#define MSR_DRAM_POWER_INFO   0x61C

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

MSR_DRAM_POWER_LIMIT

#define MSR_DRAM_POWER_LIMIT   0x618

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

MSR_INTEL_PKG_ENERGY_STATUS

#define MSR_INTEL_PKG_ENERGY_STATUS   0x611

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

MSR_INTEL_PP0_ENERGY_STATUS

#define MSR_INTEL_PP0_ENERGY_STATUS   0x639

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

MSR_INTEL_RAPL_POWER_UNIT

#define MSR_INTEL_RAPL_POWER_UNIT   0x606

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

MSR_PKG_PERF_STATUS

#define MSR_PKG_PERF_STATUS   0x613

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

MSR_PKG_POWER_INFO

#define MSR_PKG_POWER_INFO   0x614

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

MSR_PKG_RAPL_POWER_LIMIT

#define MSR_PKG_RAPL_POWER_LIMIT   0x610

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

MSR_PLATFORM_ENERGY_STATUS

#define MSR_PLATFORM_ENERGY_STATUS   0x64d

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

MSR_PP0_PERF_STATUS

#define MSR_PP0_PERF_STATUS   0x63B

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

MSR_PP0_POLICY

#define MSR_PP0_POLICY   0x63A

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

MSR_PP0_POWER_LIMIT

#define MSR_PP0_POWER_LIMIT   0x638

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

MSR_PP1_ENERGY_STATUS

#define MSR_PP1_ENERGY_STATUS   0x641

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

MSR_PP1_POLICY

#define MSR_PP1_POLICY   0x642

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

MSR_PP1_POWER_LIMIT

#define MSR_PP1_POWER_LIMIT   0x640

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

PACKAGE_ENERGY

#define PACKAGE_ENERGY   0

Definition at line 156 of file linux-rapl.c.

PACKAGE_ENERGY_CNT

#define PACKAGE_ENERGY_CNT   5

Definition at line 161 of file linux-rapl.c.

PACKAGE_MAXIMUM

#define PACKAGE_MAXIMUM   3

Definition at line 159 of file linux-rapl.c.

PACKAGE_MAXIMUM_CNT

#define PACKAGE_MAXIMUM_CNT   8

Definition at line 164 of file linux-rapl.c.

PACKAGE_MINIMUM

#define PACKAGE_MINIMUM   2

Definition at line 158 of file linux-rapl.c.

PACKAGE_MINIMUM_CNT

#define PACKAGE_MINIMUM_CNT   7

Definition at line 163 of file linux-rapl.c.

PACKAGE_THERMAL

#define PACKAGE_THERMAL   1

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

PACKAGE_THERMAL_CNT

#define PACKAGE_THERMAL_CNT   6

Definition at line 162 of file linux-rapl.c.

PACKAGE_TIME_WINDOW

#define PACKAGE_TIME_WINDOW   4

Definition at line 160 of file linux-rapl.c.

PACKAGE_TIME_WINDOW_CNT

#define PACKAGE_TIME_WINDOW_CNT   9

Definition at line 165 of file linux-rapl.c.

PLATFORM_ENERGY

#define PLATFORM_ENERGY   11

Definition at line 167 of file linux-rapl.c.

POWER_INFO_UNIT_MASK

#define POWER_INFO_UNIT_MASK   0x7fff

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

POWER_UNIT_MASK

#define POWER_UNIT_MASK   0x0f

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

POWER_UNIT_OFFSET

#define POWER_UNIT_OFFSET   0

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

RAPL_MAX_COUNTERS

#define RAPL_MAX_COUNTERS   64

Definition at line 122 of file linux-rapl.c.

THERMAL_SHIFT

#define THERMAL_SHIFT   0

Definition at line 93 of file linux-rapl.c.

TIME_UNIT_MASK

#define TIME_UNIT_MASK   0x0f

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

TIME_UNIT_OFFSET

#define TIME_UNIT_OFFSET   0x10

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

Function Documentation

_rapl_ctl()

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

static

Definition at line 993 of file linux-rapl.c.

{
    ( void ) ctx;
    ( void ) code;
    ( void ) option;

    return PAPI_OK;
}

_rapl_init_component()

static int _rapl_init_component ( int  cidx )

static

Definition at line 321 of file linux-rapl.c.

{
     int i,j,k,fd;
     FILE *fff;
     char filename[BUFSIZ];

    int package_avail, dram_avail, pp0_avail, pp1_avail, psys_avail;
    int different_units;

     long long result;
     int package;

     const PAPI_hw_info_t *hw_info;

     int nr_cpus = get_kernel_nr_cpus();
     int packages[nr_cpus];
     int cpu_to_use[nr_cpus];

    unsigned int msr_pkg_energy_status,msr_pp0_energy_status;


     /* Fill with sentinel values */
     for (i=0; i<nr_cpus; ++i) {
       packages[i] = -1;
       cpu_to_use[i] = -1;
     }


    /* check if supported processor */
    hw_info=&(_papi_hwi_system_info.hw_info);

    /* Ugh can't use PAPI_get_hardware_info() if
        PAPI library not done initializing yet */

    switch(hw_info->vendor) {
        case PAPI_VENDOR_INTEL:
        case PAPI_VENDOR_AMD:
            break;
        default:
            strncpy(_rapl_vector.cmp_info.disabled_reason,
            "Not a supported processor",PAPI_MAX_STR_LEN);
                return PAPI_ENOSUPP;
    }


    /* Make sure it is a family 6 Intel Chip */

    if (hw_info->vendor==PAPI_VENDOR_INTEL) {

        msr_rapl_power_unit=MSR_INTEL_RAPL_POWER_UNIT;
        msr_pkg_energy_status=MSR_INTEL_PKG_ENERGY_STATUS;
        msr_pp0_energy_status=MSR_INTEL_PP0_ENERGY_STATUS;

        if (hw_info->cpuid_family!=6) {
            /* Not a family 6 machine */
            strncpy(_rapl_vector.cmp_info.disabled_reason,
                "CPU family not supported",PAPI_MAX_STR_LEN);
            return PAPI_ENOIMPL;
        }

        /* Detect RAPL support */
        switch(hw_info->cpuid_model) {

        /* Desktop / Laptops */

        case 42:    /* SandyBridge */
        case 58:    /* IvyBridge */
            package_avail=1;
            pp0_avail=1;
            pp1_avail=1;
            dram_avail=0;
            psys_avail=0;
            different_units=0;
            break;

        case 60:    /* Haswell */
        case 69:    /* Haswell ULT */
        case 70:    /* Haswell GT3E */
        case 92:    /* Atom Goldmont */
        case 122:   /* Atom Gemini Lake */
        case 95:    /* Atom Denverton */
            package_avail=1;
            pp0_avail=1;
            pp1_avail=1;
            dram_avail=1;
            psys_avail=0;
            different_units=0;
            break;

        case 61:    /* Broadwell */
        case 71:    /* Broadwell-H (GT3E) */
        case 86:    /* Broadwell XEON_D */
            package_avail=1;
            pp0_avail=1;
            pp1_avail=0;
            dram_avail=1;
            psys_avail=0;
            different_units=0;
            break;

        case 78:    /* Skylake Mobile */
        case 94:    /* Skylake Desktop (H/S) */
        case 142:   /* Kabylake Mobile */
        case 158:   /* Kabylake Desktop */
            package_avail=1;
            pp0_avail=1;
            pp1_avail=0;
            dram_avail=1;
            psys_avail=1;
            different_units=0;
            break;

        /* Server Class Machines */

        case 45:    /* SandyBridge-EP */
        case 62:    /* IvyBridge-EP */
            package_avail=1;
            pp0_avail=1;
            pp1_avail=0;
            dram_avail=1;
            psys_avail=0;
            different_units=0;
            break;

        case 63:    /* Haswell-EP */
        case 79:    /* Broadwell-EP */
        case 85:    /* Skylake-X */
            package_avail=1;
            pp0_avail=1;
            pp1_avail=0;
            dram_avail=1;
            psys_avail=0;
            different_units=1;
            break;


        case 87:    /* Knights Landing (KNL) */
        case 133:   /* Knights Mill (KNM) */
            package_avail=1;
            pp0_avail=0;
            pp1_avail=0;
            dram_avail=1;
            psys_avail=0;
            different_units=1;
            break;

        default:    /* not a supported model */
            strncpy(_rapl_vector.cmp_info.disabled_reason,
                "CPU model not supported",
                PAPI_MAX_STR_LEN);
            return PAPI_ENOIMPL;
        }
    }

    if (hw_info->vendor==PAPI_VENDOR_AMD) {

        msr_rapl_power_unit=MSR_AMD_RAPL_POWER_UNIT;
        msr_pkg_energy_status=MSR_AMD_PKG_ENERGY_STATUS;
        msr_pp0_energy_status=MSR_AMD_PP0_ENERGY_STATUS;

        if (hw_info->cpuid_family!=0x17) {
            /* Not a family 17h machine */
            strncpy(_rapl_vector.cmp_info.disabled_reason,
                "CPU family not supported",PAPI_MAX_STR_LEN);
            return PAPI_ENOIMPL;
        }

        package_avail=1;
        pp0_avail=1;        /* Doesn't work on EPYC? */
        pp1_avail=0;
        dram_avail=0;
        psys_avail=0;
        different_units=0;
    }


     /* Detect how many packages */
     j=0;
     while(1) {
       int num_read;

       sprintf(filename,
           "/sys/devices/system/cpu/cpu%d/topology/physical_package_id",j);
       fff=fopen(filename,"r");
       if (fff==NULL) break;
       num_read=fscanf(fff,"%d",&package);
       fclose(fff);
       if (num_read!=1) {
             strcpy(_rapl_vector.cmp_info.disabled_reason, "Error reading file: ");
             strncat(_rapl_vector.cmp_info.disabled_reason, filename, PAPI_MAX_STR_LEN - strlen(_rapl_vector.cmp_info.disabled_reason) - 1);
             _rapl_vector.cmp_info.disabled_reason[PAPI_MAX_STR_LEN-1] = '\0';
             return PAPI_ESYS;
       }

       /* Check if a new package */
       if ((package >= 0) && (package < nr_cpus)) {
         if (packages[package] == -1) {
           SUBDBG("Found package %d out of total %d\n",package,num_packages);
       packages[package]=package;
       cpu_to_use[package]=j;
       num_packages++;
         }
       } else {
     SUBDBG("Package outside of allowed range\n");
     strncpy(_rapl_vector.cmp_info.disabled_reason,
        "Package outside of allowed range",PAPI_MAX_STR_LEN);
     return PAPI_ESYS;
       }

       j++;
     }
     num_cpus=j;

     if (num_packages==0) {
        SUBDBG("Can't access /dev/cpu/*/<msr_safe | msr>\n");
    strncpy(_rapl_vector.cmp_info.disabled_reason,
        "Can't access /dev/cpu/*/<msr_safe | msr>",PAPI_MAX_STR_LEN);
    return PAPI_ESYS;
     }

     SUBDBG("Found %d packages with %d cpus\n",num_packages,num_cpus);

     /* Init fd_array */

     fd_array=papi_calloc(num_cpus, sizeof(struct fd_array_t));
     if (fd_array==NULL) return PAPI_ENOMEM;

     fd=open_fd(cpu_to_use[0]);
     if (fd<0) {
        sprintf(_rapl_vector.cmp_info.disabled_reason,
        "Can't open fd for cpu0: %s",strerror(errno));
        return PAPI_ESYS;
     }

     /* Verify needed MSR is readable. In a guest VM it may not be readable*/
     if (pread(fd, &result, sizeof result, msr_rapl_power_unit) != sizeof result ) {
        strncpy(_rapl_vector.cmp_info.disabled_reason,
               "Unable to access RAPL registers",PAPI_MAX_STR_LEN);
        return PAPI_ESYS;
     }

     /* Calculate the units used */
     result=read_msr(fd,msr_rapl_power_unit);

     /* units are 0.5^UNIT_VALUE */
     /* which is the same as 1/(2^UNIT_VALUE) */

     power_divisor=1<<((result>>POWER_UNIT_OFFSET)&POWER_UNIT_MASK);
     cpu_energy_divisor=1<<((result>>ENERGY_UNIT_OFFSET)&ENERGY_UNIT_MASK);
     time_divisor=1<<((result>>TIME_UNIT_OFFSET)&TIME_UNIT_MASK);

    /* Note! On Haswell-EP DRAM energy is fixed at 15.3uJ   */
    /* see https://lkml.org/lkml/2015/3/20/582      */
    /* Knights Landing is the same */
    /* so is Broadwell-EP */
    if ( different_units ) {
        dram_energy_divisor=1<<16;
    }
    else {
        dram_energy_divisor=cpu_energy_divisor;
    }

     SUBDBG("Power units = %.3fW\n",1.0/power_divisor);
     SUBDBG("CPU Energy units = %.8fJ\n",1.0/cpu_energy_divisor);
     SUBDBG("DRAM Energy units = %.8fJ\n",1.0/dram_energy_divisor);
     SUBDBG("Time units = %.8fs\n",1.0/time_divisor);

     /* Allocate space for events */
     /* Include room for both counts and scaled values */

     num_events= ((package_avail*num_packages) +
                 (pp0_avail*num_packages) +
                 (pp1_avail*num_packages) +
                 (dram_avail*num_packages) +
        (psys_avail*num_packages)) * 2;

    if (hw_info->vendor==PAPI_VENDOR_INTEL) {
        num_events+=(4*num_packages) * 2;
    }

     rapl_native_events = (_rapl_native_event_entry_t*)
          papi_calloc(num_events, sizeof(_rapl_native_event_entry_t));


     i = 0;
     k = num_events/2;

     /* Create events for package power info */

    if (hw_info->vendor==PAPI_VENDOR_INTEL)
     for(j=0;j<num_packages;j++) {
        sprintf(rapl_native_events[i].name,
            "THERMAL_SPEC_CNT:PACKAGE%d",j);
        sprintf(rapl_native_events[i].description,
           "Thermal specification in counts; package %d",j);
        rapl_native_events[i].fd_offset=cpu_to_use[j];
        rapl_native_events[i].msr=MSR_PKG_POWER_INFO;
        rapl_native_events[i].resources.selector = i + 1;
        rapl_native_events[i].type=PACKAGE_THERMAL_CNT;
        rapl_native_events[i].return_type=PAPI_DATATYPE_UINT64;

        sprintf(rapl_native_events[k].name,
            "THERMAL_SPEC:PACKAGE%d",j);
        strncpy(rapl_native_events[k].units,"W",PAPI_MIN_STR_LEN);
        sprintf(rapl_native_events[k].description,
           "Thermal specification for package %d",j);
        rapl_native_events[k].fd_offset=cpu_to_use[j];
        rapl_native_events[k].msr=MSR_PKG_POWER_INFO;
        rapl_native_events[k].resources.selector = k + 1;
        rapl_native_events[k].type=PACKAGE_THERMAL;
        rapl_native_events[k].return_type=PAPI_DATATYPE_FP64;

        i++;
        k++;
     }

    if (hw_info->vendor==PAPI_VENDOR_INTEL)
     for(j=0;j<num_packages;j++) {
        sprintf(rapl_native_events[i].name,
            "MINIMUM_POWER_CNT:PACKAGE%d",j);
        sprintf(rapl_native_events[i].description,
           "Minimum power in counts; package %d",j);
        rapl_native_events[i].fd_offset=cpu_to_use[j];
        rapl_native_events[i].msr=MSR_PKG_POWER_INFO;
        rapl_native_events[i].resources.selector = i + 1;
        rapl_native_events[i].type=PACKAGE_MINIMUM_CNT;
        rapl_native_events[i].return_type=PAPI_DATATYPE_UINT64;

        sprintf(rapl_native_events[k].name,
            "MINIMUM_POWER:PACKAGE%d",j);
        strncpy(rapl_native_events[k].units,"W",PAPI_MIN_STR_LEN);
        sprintf(rapl_native_events[k].description,
           "Minimum power for package %d",j);
        rapl_native_events[k].fd_offset=cpu_to_use[j];
        rapl_native_events[k].msr=MSR_PKG_POWER_INFO;
        rapl_native_events[k].resources.selector = k + 1;
        rapl_native_events[k].type=PACKAGE_MINIMUM;
        rapl_native_events[k].return_type=PAPI_DATATYPE_FP64;

        i++;
        k++;
     }

    if (hw_info->vendor==PAPI_VENDOR_INTEL)
     for(j=0;j<num_packages;j++) {
        sprintf(rapl_native_events[i].name,
            "MAXIMUM_POWER_CNT:PACKAGE%d",j);
        sprintf(rapl_native_events[i].description,
           "Maximum power in counts; package %d",j);
        rapl_native_events[i].fd_offset=cpu_to_use[j];
        rapl_native_events[i].msr=MSR_PKG_POWER_INFO;
        rapl_native_events[i].resources.selector = i + 1;
        rapl_native_events[i].type=PACKAGE_MAXIMUM_CNT;
        rapl_native_events[i].return_type=PAPI_DATATYPE_UINT64;

        sprintf(rapl_native_events[k].name,
            "MAXIMUM_POWER:PACKAGE%d",j);
        strncpy(rapl_native_events[k].units,"W",PAPI_MIN_STR_LEN);
        sprintf(rapl_native_events[k].description,
           "Maximum power for package %d",j);
        rapl_native_events[k].fd_offset=cpu_to_use[j];
        rapl_native_events[k].msr=MSR_PKG_POWER_INFO;
        rapl_native_events[k].resources.selector = k + 1;
        rapl_native_events[k].type=PACKAGE_MAXIMUM;
        rapl_native_events[k].return_type=PAPI_DATATYPE_FP64;

        i++;
        k++;
     }

    if (hw_info->vendor==PAPI_VENDOR_INTEL)
     for(j=0;j<num_packages;j++) {
        sprintf(rapl_native_events[i].name,
            "MAXIMUM_TIME_WINDOW_CNT:PACKAGE%d",j);
        sprintf(rapl_native_events[i].description,
           "Maximum time window in counts; package %d",j);
        rapl_native_events[i].fd_offset=cpu_to_use[j];
        rapl_native_events[i].msr=MSR_PKG_POWER_INFO;
        rapl_native_events[i].resources.selector = i + 1;
        rapl_native_events[i].type=PACKAGE_TIME_WINDOW_CNT;
        rapl_native_events[i].return_type=PAPI_DATATYPE_UINT64;

        sprintf(rapl_native_events[k].name,
            "MAXIMUM_TIME_WINDOW:PACKAGE%d",j);
        strncpy(rapl_native_events[k].units,"s",PAPI_MIN_STR_LEN);
        sprintf(rapl_native_events[k].description,
           "Maximum time window for package %d",j);
        rapl_native_events[k].fd_offset=cpu_to_use[j];
        rapl_native_events[k].msr=MSR_PKG_POWER_INFO;
        rapl_native_events[k].resources.selector = k + 1;
        rapl_native_events[k].type=PACKAGE_TIME_WINDOW;
        rapl_native_events[k].return_type=PAPI_DATATYPE_FP64;

        i++;
        k++;
     }

     /* Create Events for energy measurements */

     if (package_avail) {
        for(j=0;j<num_packages;j++) {
            sprintf(rapl_native_events[i].name,
                "PACKAGE_ENERGY_CNT:PACKAGE%d",j);
            sprintf(rapl_native_events[i].description,
                "Energy used in counts by chip package %d",j);
            rapl_native_events[i].fd_offset=cpu_to_use[j];
            rapl_native_events[i].msr=msr_pkg_energy_status;
            rapl_native_events[i].resources.selector = i + 1;
            rapl_native_events[i].type=PACKAGE_ENERGY_CNT;
            rapl_native_events[i].return_type=PAPI_DATATYPE_UINT64;

            sprintf(rapl_native_events[k].name,
                "PACKAGE_ENERGY:PACKAGE%d",j);
            strncpy(rapl_native_events[k].units,"nJ",PAPI_MIN_STR_LEN);
            sprintf(rapl_native_events[k].description,
                "Energy used by chip package %d",j);
            rapl_native_events[k].fd_offset=cpu_to_use[j];
            rapl_native_events[k].msr=msr_pkg_energy_status;
            rapl_native_events[k].resources.selector = k + 1;
            rapl_native_events[k].type=PACKAGE_ENERGY;
            rapl_native_events[k].return_type=PAPI_DATATYPE_UINT64;

            i++;
            k++;
        }
     }

     if (pp1_avail) {
        for(j=0;j<num_packages;j++) {
            sprintf(rapl_native_events[i].name,
                "PP1_ENERGY_CNT:PACKAGE%d",j);
            sprintf(rapl_native_events[i].description,
                "Energy used in counts by Power Plane 1 (Often GPU) on package %d",j);
            rapl_native_events[i].fd_offset=cpu_to_use[j];
            rapl_native_events[i].msr=MSR_PP1_ENERGY_STATUS;
            rapl_native_events[i].resources.selector = i + 1;
            rapl_native_events[i].type=PACKAGE_ENERGY_CNT;
            rapl_native_events[i].return_type=PAPI_DATATYPE_UINT64;

            sprintf(rapl_native_events[k].name,
                "PP1_ENERGY:PACKAGE%d",j);
            strncpy(rapl_native_events[k].units,"nJ",PAPI_MIN_STR_LEN);
            sprintf(rapl_native_events[k].description,
                "Energy used by Power Plane 1 (Often GPU) on package %d",j);
            rapl_native_events[k].fd_offset=cpu_to_use[j];
            rapl_native_events[k].msr=MSR_PP1_ENERGY_STATUS;
            rapl_native_events[k].resources.selector = k + 1;
            rapl_native_events[k].type=PACKAGE_ENERGY;
            rapl_native_events[k].return_type=PAPI_DATATYPE_UINT64;

            i++;
            k++;
        }
     }

     if (dram_avail) {
        for(j=0;j<num_packages;j++) {
            sprintf(rapl_native_events[i].name,
                "DRAM_ENERGY_CNT:PACKAGE%d",j);
            sprintf(rapl_native_events[i].description,
                "Energy used in counts by DRAM on package %d",j);
            rapl_native_events[i].fd_offset=cpu_to_use[j];
            rapl_native_events[i].msr=MSR_DRAM_ENERGY_STATUS;
            rapl_native_events[i].resources.selector = i + 1;
            rapl_native_events[i].type=PACKAGE_ENERGY_CNT;
            rapl_native_events[i].return_type=PAPI_DATATYPE_UINT64;

            sprintf(rapl_native_events[k].name,
                "DRAM_ENERGY:PACKAGE%d",j);
            strncpy(rapl_native_events[k].units,"nJ",PAPI_MIN_STR_LEN);
            sprintf(rapl_native_events[k].description,
                "Energy used by DRAM on package %d",j);
            rapl_native_events[k].fd_offset=cpu_to_use[j];
            rapl_native_events[k].msr=MSR_DRAM_ENERGY_STATUS;
            rapl_native_events[k].resources.selector = k + 1;
            rapl_native_events[k].type=DRAM_ENERGY;
            rapl_native_events[k].return_type=PAPI_DATATYPE_UINT64;

            i++;
            k++;
        }
     }

     if (psys_avail) {
        for(j=0;j<num_packages;j++) {

            sprintf(rapl_native_events[i].name,
                "PSYS_ENERGY_CNT:PACKAGE%d",j);
            sprintf(rapl_native_events[i].description,
                "Energy used in counts by SoC on package %d",j);
            rapl_native_events[i].fd_offset=cpu_to_use[j];
            rapl_native_events[i].msr=MSR_PLATFORM_ENERGY_STATUS;
            rapl_native_events[i].resources.selector = i + 1;
            rapl_native_events[i].type=PACKAGE_ENERGY_CNT;
            rapl_native_events[i].return_type=PAPI_DATATYPE_UINT64;

            sprintf(rapl_native_events[k].name,
                "PSYS_ENERGY:PACKAGE%d",j);
            strncpy(rapl_native_events[k].units,"nJ",PAPI_MIN_STR_LEN);
            sprintf(rapl_native_events[k].description,
                "Energy used by SoC on package %d",j);
            rapl_native_events[k].fd_offset=cpu_to_use[j];
            rapl_native_events[k].msr=MSR_PLATFORM_ENERGY_STATUS;
            rapl_native_events[k].resources.selector = k + 1;
            rapl_native_events[k].type=PLATFORM_ENERGY;
            rapl_native_events[k].return_type=PAPI_DATATYPE_UINT64;

            i++;
            k++;
        }
     }

     if (pp0_avail) {
        for(j=0;j<num_packages;j++) {
            sprintf(rapl_native_events[i].name,
                "PP0_ENERGY_CNT:PACKAGE%d",j);
            sprintf(rapl_native_events[i].description,
                "Energy used in counts by all cores in package %d",j);
            rapl_native_events[i].fd_offset=cpu_to_use[j];
            rapl_native_events[i].msr=msr_pp0_energy_status;
            rapl_native_events[i].resources.selector = i + 1;
            rapl_native_events[i].type=PACKAGE_ENERGY_CNT;
            rapl_native_events[i].return_type=PAPI_DATATYPE_UINT64;

            sprintf(rapl_native_events[k].name,
                "PP0_ENERGY:PACKAGE%d",j);
            strncpy(rapl_native_events[k].units,"nJ",PAPI_MIN_STR_LEN);
            sprintf(rapl_native_events[k].description,
                "Energy used by all cores in package %d",j);
            rapl_native_events[k].fd_offset=cpu_to_use[j];
            rapl_native_events[k].msr=msr_pp0_energy_status;
            rapl_native_events[k].resources.selector = k + 1;
            rapl_native_events[k].type=PACKAGE_ENERGY;
            rapl_native_events[k].return_type=PAPI_DATATYPE_UINT64;

            i++;
            k++;
        }
     }

     /* Export the total number of events available */
     _rapl_vector.cmp_info.num_native_events = num_events;

     _rapl_vector.cmp_info.num_cntrs = num_events;
     _rapl_vector.cmp_info.num_mpx_cntrs = num_events;


     /* Export the component id */
     _rapl_vector.cmp_info.CmpIdx = cidx;

     return PAPI_OK;
}

Here is the call graph for this function:

_rapl_init_control_state()

static int _rapl_init_control_state ( hwd_control_state_t *  ctl )

static

Definition at line 880 of file linux-rapl.c.

{

  _rapl_control_state_t* control = (_rapl_control_state_t*) ctl;
  int i;

  for(i=0;i<RAPL_MAX_COUNTERS;i++) {
     control->being_measured[i]=0;
  }

  return PAPI_OK;
}

_rapl_init_thread()

static int _rapl_init_thread ( hwd_context_t *  ctx )

static

Definition at line 308 of file linux-rapl.c.

{
  ( void ) ctx;

  return PAPI_OK;
}

_rapl_ntv_code_to_descr()

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

static

Definition at line 1132 of file linux-rapl.c.

{
     int index = EventCode;

     if ( index >= 0 && index < num_events ) {
    strncpy( name, rapl_native_events[index].description, len );
    return PAPI_OK;
     }
     return PAPI_ENOEVNT;
}

_rapl_ntv_code_to_info()

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

static

Definition at line 1144 of file linux-rapl.c.

{

  int index = EventCode;

  if ( ( index < 0) || (index >= num_events )) return PAPI_ENOEVNT;

  strncpy( info->symbol, rapl_native_events[index].name, sizeof(info->symbol)-1);
  info->symbol[sizeof(info->symbol)-1] = '\0';

  strncpy( info->long_descr, rapl_native_events[index].description, sizeof(info->long_descr)-1);
  info->long_descr[sizeof(info->long_descr)-1] = '\0';

  strncpy( info->units, rapl_native_events[index].units, sizeof(info->units)-1);
  info->units[sizeof(info->units)-1] = '\0';

  info->data_type = rapl_native_events[index].return_type;

  return PAPI_OK;
}

_rapl_ntv_code_to_name()

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

static

Definition at line 1115 of file linux-rapl.c.

{

     int index = EventCode & PAPI_NATIVE_AND_MASK;

     if ( index >= 0 && index < num_events ) {
    strncpy( name, rapl_native_events[index].name, len );
    return PAPI_OK;
     }

     return PAPI_ENOEVNT;
}

_rapl_ntv_enum_events()

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

static

Definition at line 1075 of file linux-rapl.c.

{

     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;
}

_rapl_read()

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

Definition at line 954 of file linux-rapl.c.

{
    (void) flags;

    _rapl_stop( ctx, ctl );

    /* Pass back a pointer to our results */
    *events = ((_rapl_control_state_t*) ctl)->count;

    return PAPI_OK;
}

Here is the call graph for this function:

_rapl_reset()

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

static

Definition at line 1062 of file linux-rapl.c.

{
    ( void ) ctx;
    ( void ) ctl;

    return PAPI_OK;
}

_rapl_set_domain()

static int _rapl_set_domain ( hwd_control_state_t *  ctl, int  domain  )

static

Definition at line 1048 of file linux-rapl.c.

{
    ( void ) ctl;

    /* In theory we only support system-wide mode */
    /* How to best handle that? */
    if ( PAPI_DOM_ALL != domain )
    return PAPI_EINVAL;

    return PAPI_OK;
}

_rapl_shutdown_component()

static int _rapl_shutdown_component ( void  )

static

Definition at line 972 of file linux-rapl.c.

{
    int i;

    if (rapl_native_events) papi_free(rapl_native_events);
    if (fd_array) {
       for(i=0;i<num_cpus;i++) {
      if (fd_array[i].open) close(fd_array[i].fd);
       }
       papi_free(fd_array);
    }

    return PAPI_OK;
}

Here is the call graph for this function:

_rapl_shutdown_thread()

static int _rapl_shutdown_thread ( hwd_context_t *  ctx )

static

Definition at line 947 of file linux-rapl.c.

{
  ( void ) ctx;
  return PAPI_OK;
}

_rapl_start()

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

static

Definition at line 894 of file linux-rapl.c.

{
  _rapl_context_t* context = (_rapl_context_t*) ctx;
  _rapl_control_state_t* control = (_rapl_control_state_t*) ctl;
  long long now = PAPI_get_real_usec();
  int i;

  for( i = 0; i < RAPL_MAX_COUNTERS; i++ ) {
     if ((control->being_measured[i]) && (control->need_difference[i])) {
        context->start_value[i]=read_rapl_value(i);
     }
  }

  control->lastupdate = now;

  return PAPI_OK;
}

Here is the call graph for this function:

_rapl_stop()

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

static

Definition at line 913 of file linux-rapl.c.

{

    /* read values */
    _rapl_context_t* context = (_rapl_context_t*) ctx;
    _rapl_control_state_t* control = (_rapl_control_state_t*) ctl;
    long long now = PAPI_get_real_usec();
    int i;
    long long temp;

    for ( i = 0; i < RAPL_MAX_COUNTERS; i++ ) {
        if (control->being_measured[i]) {
            temp = read_rapl_value(i);
            if (context->start_value[i])
            if (control->need_difference[i]) {
                /* test for wrap around */
                if (temp < context->start_value[i] ) {
                    SUBDBG("Wraparound!\nstart:\t%#016x\ttemp:\t%#016x",
                        (unsigned)context->start_value[i], (unsigned)temp);
                    temp += (0x100000000 - context->start_value[i]);
                    SUBDBG("\tresult:\t%#016x\n", (unsigned)temp);
                } else {
                    temp -= context->start_value[i];
                }
            }
            control->count[i] = convert_rapl_energy( i, temp );
        }
    }
    control->lastupdate = now;
    return PAPI_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_rapl_update_control_state()

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

static

Definition at line 1004 of file linux-rapl.c.

{
  int i, index;
    ( void ) ctx;

    _rapl_control_state_t* control = (_rapl_control_state_t*) ctl;

    /* Ugh, what is this native[] stuff all about ?*/
    /* Mostly remap stuff in papi_internal */

    for(i=0;i<RAPL_MAX_COUNTERS;i++) {
       control->being_measured[i]=0;
    }

    for( i = 0; i < count; i++ ) {
       index=native[i].ni_event&PAPI_NATIVE_AND_MASK;
       native[i].ni_position=rapl_native_events[index].resources.selector - 1;
       control->being_measured[index]=1;

       /* Only need to subtract if it's a PACKAGE_ENERGY or ENERGY_CNT type */
       control->need_difference[index]=
        (rapl_native_events[index].type==PACKAGE_ENERGY ||
        rapl_native_events[index].type==DRAM_ENERGY ||
        rapl_native_events[index].type==PLATFORM_ENERGY ||
        rapl_native_events[index].type==PACKAGE_ENERGY_CNT);
    }

    return PAPI_OK;
}

convert_rapl_energy()

static long long convert_rapl_energy ( int  index, long long  value  )

static

Definition at line 220 of file linux-rapl.c.

                                                                 {

   union {
      long long ll;
      double fp;
   } return_val;

   return_val.ll = value; /* default case: return raw input value */

   if (rapl_native_events[index].type==PACKAGE_ENERGY) {
      return_val.ll = (long long)(((double)value/cpu_energy_divisor)*1e9);
   }

   if (rapl_native_events[index].type==DRAM_ENERGY) {
      return_val.ll = (long long)(((double)value/dram_energy_divisor)*1e9);
   }

   if (rapl_native_events[index].type==PLATFORM_ENERGY) {
      return_val.ll = (long long)(((double)value/cpu_energy_divisor)*1e9);
   }

   if (rapl_native_events[index].type==PACKAGE_THERMAL) {
      return_val.fp = (double)
                      ((value>>THERMAL_SHIFT)&POWER_INFO_UNIT_MASK) /
                       (double)power_divisor;
   }

   if (rapl_native_events[index].type==PACKAGE_MINIMUM) {
       return_val.fp = (double)
                       ((value>>MINIMUM_POWER_SHIFT)&POWER_INFO_UNIT_MASK)/
                        (double)power_divisor;
   }

   if (rapl_native_events[index].type==PACKAGE_MAXIMUM) {
      return_val.fp = (double)
                      ((value>>MAXIMUM_POWER_SHIFT)&POWER_INFO_UNIT_MASK)/
                       (double)power_divisor;
   }

   if (rapl_native_events[index].type==PACKAGE_TIME_WINDOW) {
      return_val.fp =  (double)
                    ((value>>MAXIMUM_TIME_WINDOW_SHIFT)&POWER_INFO_UNIT_MASK)/
                     (double)time_divisor;
   }

   if (rapl_native_events[index].type==PACKAGE_THERMAL_CNT) {
      return_val.ll = ((value>>THERMAL_SHIFT)&POWER_INFO_UNIT_MASK);
   }

   if (rapl_native_events[index].type==PACKAGE_MINIMUM_CNT) {
       return_val.ll = ((value>>MINIMUM_POWER_SHIFT)&POWER_INFO_UNIT_MASK);
   }

   if (rapl_native_events[index].type==PACKAGE_MAXIMUM_CNT) {
      return_val.ll = ((value>>MAXIMUM_POWER_SHIFT)&POWER_INFO_UNIT_MASK);
   }

   if (rapl_native_events[index].type==PACKAGE_TIME_WINDOW_CNT) {
      return_val.ll = ((value>>MAXIMUM_TIME_WINDOW_SHIFT)&POWER_INFO_UNIT_MASK);
   }

   return return_val.ll;
}

Here is the caller graph for this function:

get_kernel_nr_cpus()

static int get_kernel_nr_cpus ( void  )

static

Definition at line 285 of file linux-rapl.c.

{
  FILE *fff;
  int num_read, nr_cpus = 1;
  fff=fopen("/sys/devices/system/cpu/kernel_max","r");
  if (fff==NULL) return nr_cpus;
  num_read=fscanf(fff,"%d",&nr_cpus);
  fclose(fff);
  if (num_read==1) {
    nr_cpus++;
  } else {
    nr_cpus = 1;
  }
  return nr_cpus;
}

Here is the caller graph for this function:

open_fd()

static int open_fd ( int  offset )

static

Definition at line 187 of file linux-rapl.c.

                               {
  
  int fd=-1;
  char filename[BUFSIZ];

  if (fd_array[offset].open==0) {
      sprintf(filename,"/dev/cpu/%d/msr_safe",offset);
      fd = open(filename, O_RDONLY);
      if (fd<0) {
          sprintf(filename,"/dev/cpu/%d/msr",offset);
          fd = open(filename, O_RDONLY);
      }
      if (fd>=0) {
          fd_array[offset].fd=fd;
          fd_array[offset].open=1;
      } 
  }
  else {
    fd=fd_array[offset].fd;
  }

  return fd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_msr()

static long long read_msr ( int  fd, unsigned int  which  )

static

Definition at line 174 of file linux-rapl.c.

                                                      {

    uint64_t data;

    if ( fd<0 || pread(fd, &data, sizeof data, which) != sizeof data ) {
        perror("rdmsr:pread");
        fprintf(stderr,"rdmsr error, msr %x\n",which);
        exit(127);
    }

    return (long long)data;
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_rapl_value()

static long long read_rapl_value ( int  index )

static

Definition at line 211 of file linux-rapl.c.

                                            {

   int fd;

   fd=open_fd(rapl_native_events[index].fd_offset);
   return read_msr(fd,rapl_native_events[index].msr);

}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

_rapl_vector

papi_vector_t _rapl_vector

Definition at line 140 of file linux-rapl.c.

cpu_energy_divisor

int cpu_energy_divisor

Definition at line 153 of file linux-rapl.c.

dram_energy_divisor

int dram_energy_divisor

Definition at line 153 of file linux-rapl.c.

fd_array

struct fd_array_t* fd_array =NULL

Definition at line 149 of file linux-rapl.c.

msr_rapl_power_unit

unsigned int msr_rapl_power_unit

Definition at line 154 of file linux-rapl.c.

num_cpus

int num_cpus =0

static

Definition at line 150 of file linux-rapl.c.

num_events

int num_events = 0

static

Definition at line 148 of file linux-rapl.c.

num_packages

int num_packages =0

static

Definition at line 150 of file linux-rapl.c.

power_divisor

int power_divisor

Definition at line 152 of file linux-rapl.c.

rapl_native_events

_rapl_native_event_entry_t* rapl_native_events =NULL

static

Definition at line 147 of file linux-rapl.c.

time_divisor

int time_divisor

Definition at line 152 of file linux-rapl.c.