tools/power/cpupower/utils/idle_monitor/mperf_monitor.c

   1 /*
   2  *  (C) 2010,2011       Thomas Renninger <trenn@suse.de>, Novell Inc.
   3  *
   4  *  Licensed under the terms of the GNU GPL License version 2.
   5  */
   6
   7 #if defined(__i386__) || defined(__x86_64__)
   8
   9 #include <stdio.h>
  10 #include <stdint.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <limits.h>
  14
  15 #include <cpufreq.h>
  16
  17 #include "helpers/helpers.h"
  18 #include "idle_monitor/cpupower-monitor.h"
  19
  20 #define MSR_APERF       0xE8
  21 #define MSR_MPERF       0xE7
  22
  23 #define MSR_TSC 0x10
  24
  25 #define MSR_AMD_HWCR 0xc0010015
  26
  27 enum mperf_id { C0 = 0, Cx, AVG_FREQ, MPERF_CSTATE_COUNT };
  28
  29 static int mperf_get_count_percent(unsigned int self_id, double *percent,
  30                                    unsigned int cpu);
  31 static int mperf_get_count_freq(unsigned int id, unsigned long long *count,
  32                                 unsigned int cpu);
  33 static struct timespec time_start, time_end;
  34
  35 static cstate_t mperf_cstates[MPERF_CSTATE_COUNT] = {
  36         {
  37                 .name                   = "C0",
  38                 .desc                   = N_("Processor Core not idle"),
  39                 .id                     = C0,
  40                 .range                  = RANGE_THREAD,
  41                 .get_count_percent      = mperf_get_count_percent,
  42         },
  43         {
  44                 .name                   = "Cx",
  45                 .desc                   = N_("Processor Core in an idle state"),
  46                 .id                     = Cx,
  47                 .range                  = RANGE_THREAD,
  48                 .get_count_percent      = mperf_get_count_percent,
  49         },
  50
  51         {
  52                 .name                   = "Freq",
  53                 .desc                   = N_("Average Frequency (including boost) in MHz"),
  54                 .id                     = AVG_FREQ,
  55                 .range                  = RANGE_THREAD,
  56                 .get_count              = mperf_get_count_freq,
  57         },
  58 };
  59
  60 enum MAX_FREQ_MODE { MAX_FREQ_SYSFS, MAX_FREQ_TSC_REF };
  61 static int max_freq_mode;
  62 /*
  63  * The max frequency mperf is ticking at (in C0), either retrieved via:
  64  *   1) calculated after measurements if we know TSC ticks at mperf/P0 frequency
  65  *   2) cpufreq /sys/devices/.../cpu0/cpufreq/cpuinfo_max_freq at init time
  66  * 1. Is preferred as it also works without cpufreq subsystem (e.g. on Xen)
  67  */
  68 static unsigned long max_frequency;
  69
  70 static unsigned long long *tsc_at_measure_start;
  71 static unsigned long long *tsc_at_measure_end;
  72 static unsigned long long *mperf_previous_count;
  73 static unsigned long long *aperf_previous_count;
  74 static unsigned long long *mperf_current_count;
  75 static unsigned long long *aperf_current_count;
  76
  77 /* valid flag for all CPUs. If a MSR read failed it will be zero */
  78 static int *is_valid;
  79
  80 static int mperf_get_tsc(unsigned long long *tsc)
  81 {
  82         int ret;
  83
  84         ret = read_msr(base_cpu, MSR_TSC, tsc);
  85         if (ret)
  86                 dprint("Reading TSC MSR failed, returning %llu\n", *tsc);
  87         return ret;
  88 }
  89
  90 static int mperf_init_stats(unsigned int cpu)
  91 {
  92         unsigned long long val;
  93         int ret;
  94
  95         ret = read_msr(cpu, MSR_APERF, &val);
  96         aperf_previous_count[cpu] = val;
  97         ret |= read_msr(cpu, MSR_MPERF, &val);
  98         mperf_previous_count[cpu] = val;
  99         is_valid[cpu] = !ret;
 100
 101         return 0;
 102 }
 103
 104 static int mperf_measure_stats(unsigned int cpu)
 105 {
 106         unsigned long long val;
 107         int ret;
 108
 109         ret = read_msr(cpu, MSR_APERF, &val);
 110         aperf_current_count[cpu] = val;
 111         ret |= read_msr(cpu, MSR_MPERF, &val);
 112         mperf_current_count[cpu] = val;
 113         is_valid[cpu] = !ret;
 114
 115         return 0;
 116 }
 117
 118 static int mperf_get_count_percent(unsigned int id, double *percent,
 119                                    unsigned int cpu)
 120 {
 121         unsigned long long aperf_diff, mperf_diff, tsc_diff;
 122         unsigned long long timediff;
 123
 124         if (!is_valid[cpu])
 125                 return -1;
 126
 127         if (id != C0 && id != Cx)
 128                 return -1;
 129
 130         mperf_diff = mperf_current_count[cpu] - mperf_previous_count[cpu];
 131         aperf_diff = aperf_current_count[cpu] - aperf_previous_count[cpu];
 132
 133         if (max_freq_mode == MAX_FREQ_TSC_REF) {
 134                 tsc_diff = tsc_at_measure_end[cpu] - tsc_at_measure_start[cpu];
 135                 *percent = 100.0 * mperf_diff / tsc_diff;
 136                 dprint("%s: TSC Ref - mperf_diff: %llu, tsc_diff: %llu\n",
 137                        mperf_cstates[id].name, mperf_diff, tsc_diff);
 138         } else if (max_freq_mode == MAX_FREQ_SYSFS) {
 139                 timediff = max_frequency * timespec_diff_us(time_start, time_end);
 140                 *percent = 100.0 * mperf_diff / timediff;
 141                 dprint("%s: MAXFREQ - mperf_diff: %llu, time_diff: %llu\n",
 142                        mperf_cstates[id].name, mperf_diff, timediff);
 143         } else
 144                 return -1;
 145
 146         if (id == Cx)
 147                 *percent = 100.0 - *percent;
 148
 149         dprint("%s: previous: %llu - current: %llu - (%u)\n",
 150                 mperf_cstates[id].name, mperf_diff, aperf_diff, cpu);
 151         dprint("%s: %f\n", mperf_cstates[id].name, *percent);
 152         return 0;
 153 }
 154
 155 static int mperf_get_count_freq(unsigned int id, unsigned long long *count,
 156                                 unsigned int cpu)
 157 {
 158         unsigned long long aperf_diff, mperf_diff, time_diff, tsc_diff;
 159
 160         if (id != AVG_FREQ)
 161                 return 1;
 162
 163         if (!is_valid[cpu])
 164                 return -1;
 165
 166         mperf_diff = mperf_current_count[cpu] - mperf_previous_count[cpu];
 167         aperf_diff = aperf_current_count[cpu] - aperf_previous_count[cpu];
 168
 169         if (max_freq_mode == MAX_FREQ_TSC_REF) {
 170                 /* Calculate max_freq from TSC count */
 171                 tsc_diff = tsc_at_measure_end[cpu] - tsc_at_measure_start[cpu];
 172                 time_diff = timespec_diff_us(time_start, time_end);
 173                 max_frequency = tsc_diff / time_diff;
 174         }
 175
 176         *count = max_frequency * ((double)aperf_diff / mperf_diff);
 177         dprint("%s: Average freq based on %s maximum frequency:\n",
 178                mperf_cstates[id].name,
 179                (max_freq_mode == MAX_FREQ_TSC_REF) ? "TSC calculated" : "sysfs read");
 180         dprint("max_frequency: %lu\n", max_frequency);
 181         dprint("aperf_diff: %llu\n", aperf_diff);
 182         dprint("mperf_diff: %llu\n", mperf_diff);
 183         dprint("avg freq:   %llu\n", *count);
 184         return 0;
 185 }
 186
 187 static int mperf_start(void)
 188 {
 189         int cpu;
 190
 191         clock_gettime(CLOCK_REALTIME, &time_start);
 192
 193         for (cpu = 0; cpu < cpu_count; cpu++) {
 194                 mperf_get_tsc(&tsc_at_measure_start[cpu]);
 195                 mperf_init_stats(cpu);
 196         }
 197
 198         return 0;
 199 }
 200
 201 static int mperf_stop(void)
 202 {
 203         int cpu;
 204
 205         for (cpu = 0; cpu < cpu_count; cpu++) {
 206                 mperf_measure_stats(cpu);
 207                 mperf_get_tsc(&tsc_at_measure_end[cpu]);
 208         }
 209
 210         clock_gettime(CLOCK_REALTIME, &time_end);
 211         return 0;
 212 }
 213
 214 /*
 215  * Mperf register is defined to tick at P0 (maximum) frequency
 216  *
 217  * Instead of reading out P0 which can be tricky to read out from HW,
 218  * we use TSC counter if it reliably ticks at P0/mperf frequency.
 219  *
 220  * Still try to fall back to:
 221  * /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq
 222  * on older Intel HW without invariant TSC feature.
 223  * Or on AMD machines where TSC does not tick at P0 (do not exist yet, but
 224  * it's still double checked (MSR_AMD_HWCR)).
 225  *
 226  * On these machines the user would still get useful mperf
 227  * stats when acpi-cpufreq driver is loaded.
 228  */
 229 static int init_maxfreq_mode(void)
 230 {
 231         int ret;
 232         unsigned long long hwcr;
 233         unsigned long min;
 234
 235         if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_INV_TSC))
 236                 goto use_sysfs;
 237
 238         if (cpupower_cpu_info.vendor == X86_VENDOR_AMD) {
 239                 /* MSR_AMD_HWCR tells us whether TSC runs at P0/mperf
 240                  * freq.
 241                  * A test whether hwcr is accessable/available would be:
 242                  * (cpupower_cpu_info.family > 0x10 ||
 243                  *   cpupower_cpu_info.family == 0x10 &&
 244                  *   cpupower_cpu_info.model >= 0x2))
 245                  * This should be the case for all aperf/mperf
 246                  * capable AMD machines and is therefore safe to test here.
 247                  * Compare with Linus kernel git commit: acf01734b1747b1ec4
 248                  */
 249                 ret = read_msr(0, MSR_AMD_HWCR, &hwcr);
 250                 /*
 251                  * If the MSR read failed, assume a Xen system that did
 252                  * not explicitly provide access to it and assume TSC works
 253                 */
 254                 if (ret != 0) {
 255                         dprint("TSC read 0x%x failed - assume TSC working\n",
 256                                MSR_AMD_HWCR);
 257                         return 0;
 258                 } else if (1 & (hwcr >> 24)) {
 259                         max_freq_mode = MAX_FREQ_TSC_REF;
 260                         return 0;
 261                 } else { /* Use sysfs max frequency if available */ }
 262         } else if (cpupower_cpu_info.vendor == X86_VENDOR_INTEL) {
 263                 /*
 264                  * On Intel we assume mperf (in C0) is ticking at same
 265                  * rate than TSC
 266                  */
 267                 max_freq_mode = MAX_FREQ_TSC_REF;
 268                 return 0;
 269         }
 270 use_sysfs:
 271         if (cpufreq_get_hardware_limits(0, &min, &max_frequency)) {
 272                 dprint("Cannot retrieve max freq from cpufreq kernel "
 273                        "subsystem\n");
 274                 return -1;
 275         }
 276         max_freq_mode = MAX_FREQ_SYSFS;
 277         max_frequency /= 1000; /* Default automatically to MHz value */
 278         return 0;
 279 }
 280
 281 /*
 282  * This monitor provides:
 283  *
 284  * 1) Average frequency a CPU resided in
 285  *    This always works if the CPU has aperf/mperf capabilities
 286  *
 287  * 2) C0 and Cx (any sleep state) time a CPU resided in
 288  *    Works if mperf timer stops ticking in sleep states which
 289  *    seem to be the case on all current HW.
 290  * Both is directly retrieved from HW registers and is independent
 291  * from kernel statistics.
 292  */
 293 struct cpuidle_monitor mperf_monitor;
 294 struct cpuidle_monitor *mperf_register(void)
 295 {
 296         if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_APERF))
 297                 return NULL;
 298
 299         if (init_maxfreq_mode())
 300                 return NULL;
 301
 302         /* Free this at program termination */
 303         is_valid = calloc(cpu_count, sizeof(int));
 304         mperf_previous_count = calloc(cpu_count, sizeof(unsigned long long));
 305         aperf_previous_count = calloc(cpu_count, sizeof(unsigned long long));
 306         mperf_current_count = calloc(cpu_count, sizeof(unsigned long long));
 307         aperf_current_count = calloc(cpu_count, sizeof(unsigned long long));
 308         tsc_at_measure_start = calloc(cpu_count, sizeof(unsigned long long));
 309         tsc_at_measure_end = calloc(cpu_count, sizeof(unsigned long long));
 310         mperf_monitor.name_len = strlen(mperf_monitor.name);
 311         return &mperf_monitor;
 312 }
 313
 314 void mperf_unregister(void)
 315 {
 316         free(mperf_previous_count);
 317         free(aperf_previous_count);
 318         free(mperf_current_count);
 319         free(aperf_current_count);
 320         free(tsc_at_measure_start);
 321         free(tsc_at_measure_end);
 322         free(is_valid);
 323 }
 324
 325 struct cpuidle_monitor mperf_monitor = {
 326         .name                   = "Mperf",
 327         .hw_states_num          = MPERF_CSTATE_COUNT,
 328         .hw_states              = mperf_cstates,
 329         .start                  = mperf_start,
 330         .stop                   = mperf_stop,
 331         .do_register            = mperf_register,
 332         .unregister             = mperf_unregister,
 333         .needs_root             = 1,
 334         .overflow_s             = 922000000 /* 922337203 seconds TSC overflow
 335                                                at 20GHz */
 336 };
 337 #endif /* #if defined(__i386__) || defined(__x86_64__) */