msr_rapl.h

Go to the documentation of this file.

/* msr_rapl.h
 *
 * Copyright (c) 2011-2016, Lawrence Livermore National Security, LLC.
 * LLNL-CODE-645430
 *
 * Produced at Lawrence Livermore National Laboratory
 * Written by  Barry Rountree, rountree@llnl.gov
 *             Scott Walker,   walker91@llnl.gov
 *             Kathleen Shoga, shoga1@llnl.gov
 *
 * All rights reserved.
 *
 * This file is part of libmsr.
 *
 * libmsr is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License as published by the Free
 * Software Foundation, either version 3 of the License, or (at your option)
 * any later version.
 *
 * libmsr is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with libmsr. If not, see <http://www.gnu.org/licenses/>.
 *
 * This material is based upon work supported by the U.S. Department of
 * Energy's Lawrence Livermore National Laboratory. Office of Science, under
 * Award number DE-AC52-07NA27344.
 *
 */

#ifndef MSR_RAPL_H_INCLUDE
#define MSR_RAPL_H_INCLUDE

#include <stdint.h>
#include <stdio.h>
#include <sys/time.h>

#include "master.h"

#ifdef __cplusplus
extern "C" {
#endif

// Processor specific rapl flags (see rapl_init function)
// These indicate which rapl MSRs are available for a given cpu model
// bit: address, register
//  0: 606h, MSR_RAPL_POWER_UNIT
//  1: 610h, MSR_PKG_POWER_LIMIT
//  2: 611h, MSR_PKG_ENERGY_STATUS
//  3: 613h, MSR_PKG_PERF_STATUS
//  4: 614h, MSR_PKG_POWER_INFO
//  5: 618h, MSR_DRAM_POWER_LIMIT
//  6: 619h, MSR_DRAM_ENERGY_STATUS
//  7: 61Bi, MSR_DRAM_PERF_STATUS
//  8: 61Ch, MSR_DRAM_POWER_INFO
//  9: 638h, MSR_PP0_POWER_LIMIT
// 10: 639h, MSR_PP0_ENERGY_STATUS
// 11: 63Ah, MSR_PP0_POLICY
// 12: 63Bh, MSR_PP0_PERF_STATUS
// 13: 640h, MSR_PP1_POWER_LIMIT
// 14: 641h, MSR_PP1_ENERGY_STATUS
// 15: 642h, MSR_PP1_POLICY
// 16: 64Ch, MSR_TURBO_ACTIVATION_RATIO
// 17: 66Eh, MSR_PKG_POWER_INFO
// 18: 690h, MSR_CORE_PERF_LIMIT_REASONS
// 19: 6B0h, MSR_GRAPHICS_PERF_LIMIT_REASONS
// 20: 6B1h, MSR_RING_PERF_LIMIT_REASONS
// 21: 1ADh, MSR_TURBO_RATIO_LIMIT
// 22: 1AEh, MSR_TURBO_RATIO_LIMIT1
#define MF_06_37 (0x407)
#define MF_06_4A (0x407)
#define MF_06_5A (0x407)
#define MF_06_4D (0x20003)
#define MF_06_4C (0x607)
#define MF_06_2A (0xFE17)   // Sandy Bridge
#define MF_06_2D (0x7FF)    // Sandy Bridge
#define MF_06_3A (0xFE17)
#define MF_06_3E (0x6007F7) // Ivy Bridge
#define MF_06_3C (0x1CEE17) // disabled pp0_perf_status, not on this architecture
#define MF_06_45 (0x1CFE17)
#define MF_06_46 (0x1CFE17)
#define MF_06_3F (0x1C01FF) // disabled PP registers, not on this architecture
#define MF_06_3D (0x1CFE17)
#define MF_06_47 (0x1CFE17)
#define MF_06_4F (0x1CFE17)
#define MF_06_56 (0x1CFE17)
#define MF_06_4E (0x1EFE17)
#define MF_06_5E (0x1EFE17)
#define MF_06_57 (0x507FF)

// Register flags
// These are used to check against the rapl flags (see above) to see if a
// register exists
#define POWER_UNIT             (0x1L)
#define PKG_POWER_LIMIT        (0x2L)
#define PKG_ENERGY_STATUS      (0x4L)
#define PKG_PERF_STATUS        (0x8L)
#define PKG_POWER_INFO         (0x10L)
#define DRAM_POWER_LIMIT       (0x20L)
#define DRAM_ENERGY_STATUS     (0x40L)
#define DRAM_PERF_STATUS       (0x80L)
#define DRAM_POWER_INFO        (0x100L)
#define PP0_POWER_LIMIT        (0x200L)
#define PP0_ENERGY_STATUS      (0x400L)
#define PP0_POLICY             (0x800L)
#define PP0_PERF_STATUS        (0x1000L)
#define PP1_POWER_LIMIT        (0x2000L)
#define PP1_ENERGY_STATUS      (0x4000L)
#define PP1_POLICY             (0x8000L)
#define TURBO_ACTIVATION_RATIO (0x10000L)
#define TURBO_RATIO_LIMIT      (0x200000L)
#define TURBO_RATIO_LIMIT1     (0x400000L)


#define UINT_MAX 4294967295U // taken from limits.h
#define STD_ENERGY_UNIT 65536.0

enum libmsr_unit_conversions_e {
    BITS_TO_WATTS,
    WATTS_TO_BITS,
    BITS_TO_JOULES,
    JOULES_TO_BITS,
    BITS_TO_SECONDS_STD,
    SECONDS_TO_BITS_STD,
    BITS_TO_SECONDS_HASWELL,
    SECONDS_TO_BITS_HASWELL,
    BITS_TO_JOULES_DRAM
};

struct rapl_units {
    uint64_t msr_rapl_power_unit;
    double joules;
    double seconds;
    double watts;
};

struct rapl_data {
    /**********/
    /* Timers */
    /**********/
    struct timeval now;
    struct timeval old_now;
    double elapsed;

    /**************************/
    /* RAPL Power Domain: PKG */
    /**************************/
    uint64_t **pkg_bits;
    uint64_t *old_pkg_bits;
    double *pkg_joules;
    double *old_pkg_joules;
    double *pkg_delta_joules;
    double *pkg_watts;
    uint64_t **pkg_perf_count;

    /***************************/
    /* RAPL Power Domain: DRAM */
    /***************************/
    uint64_t **dram_bits;
    uint64_t *old_dram_bits;
    double *dram_joules;
    double *old_dram_joules;
    double *dram_delta_joules;
    double *dram_watts;
    uint64_t **dram_perf_count;

    /************************************/
    /* RAPL Power Domain: Power Plane 0 */
    /* (PP0, IA Processor Cores)        */
    /************************************/
    uint64_t **pp0_bits;
    uint64_t *old_pp0_bits;
    double *pp0_joules;
    double *old_pp0_joules;
    double *pp0_delta_joules;
    double *pp0_watts;
    uint64_t **pp0_perf_count;
    uint64_t **pp0_policy;

    /************************************/
    /* RAPL Power Domain: Power Plane 1 */
    /* (PP1, Uncore Graphic Device)     */
    /************************************/
    uint64_t **pp1_bits;
    uint64_t *old_pp1_bits;
    double  *pp1_joules;
    double *old_pp1_joules;
    double *pp1_delta_joules;
    double *pp1_watts;
    uint64_t **pp1_policy;
};

struct rapl_limit {
    uint64_t bits;
    double watts;
    double seconds;
};

struct rapl_power_info {
    /**************************/
    /* RAPL Power Domain: PKG */
    /**************************/
    uint64_t msr_pkg_power_info;
    double pkg_max_power;
    double pkg_min_power;
    double pkg_max_window;
    double pkg_therm_power;

    /***************************/
    /* RAPL Power Domain: DRAM */
    /***************************/
    uint64_t msr_dram_power_info;
    double dram_max_power;
    double dram_min_power;
    double dram_max_window;
    double dram_therm_power;
};

int rapl_storage(struct rapl_data **data,
                 uint64_t **flags);

int print_available_rapl(void);

int rapl_init(struct rapl_data **rapl,
              uint64_t **rapl_flags);

int set_pkg_rapl_limit(const unsigned socket,
                       struct rapl_limit *limit1,
                       struct rapl_limit *limit2);

int set_dram_rapl_limit(const unsigned socket,
                        struct rapl_limit *limit);

int set_pp_rapl_limit(const unsigned socket,
                      struct rapl_limit *limit0,
                      struct rapl_limit *limit1);

int get_rapl_power_info(const unsigned socket,
                        struct rapl_power_info *info);

int set_pp_rapl_policies(const unsigned socket,
                         uint64_t *pp0,
                         uint64_t *pp1);

int get_pp_rapl_policies(const unsigned socket,
                         uint64_t *pp0,
                         uint64_t *pp1);

int get_pkg_rapl_limit(const unsigned socket,
                       struct rapl_limit *limit1,
                       struct rapl_limit *limit2);

int get_dram_rapl_limit(const unsigned socket,
                        struct rapl_limit *limit);

int get_pp_rapl_limit(const unsigned socket,
                      struct rapl_limit *limit0,
                      struct rapl_limit *limit1);

void dump_rapl_limit(struct rapl_limit *L,
                     FILE *writedest);

int dump_rapl_data_terse_label(FILE *writedest);

int dump_rapl_data_terse(FILE *writedest);

int dump_rapl_data(FILE *writedest);

int dump_rapl_power_info(FILE *writedest);

int poll_rapl_data(void);

int delta_rapl_data(void);

int read_rapl_data(void);

void get_rapl_power_unit(struct rapl_units *ru);

void dump_rapl_power_unit(FILE *writedest);

#ifdef __cplusplus
}
#endif
#endif