~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/power/cpupower/utils/idle_monitor/mperf_monitor.c

Version: ~ [ linux-5.6-rc1 ] ~ [ linux-5.5.2 ] ~ [ linux-5.4.17 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.102 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.170 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.213 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.213 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 - tsc_at_measure_start;
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 - tsc_at_measure_start;
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         unsigned long long dbg;
191 
192         clock_gettime(CLOCK_REALTIME, &time_start);
193         mperf_get_tsc(&tsc_at_measure_start);
194 
195         for (cpu = 0; cpu < cpu_count; cpu++)
196                 mperf_init_stats(cpu);
197 
198         mperf_get_tsc(&dbg);
199         dprint("TSC diff: %llu\n", dbg - tsc_at_measure_start);
200         return 0;
201 }
202 
203 static int mperf_stop(void)
204 {
205         unsigned long long dbg;
206         int cpu;
207 
208         for (cpu = 0; cpu < cpu_count; cpu++)
209                 mperf_measure_stats(cpu);
210 
211         mperf_get_tsc(&tsc_at_measure_end);
212         clock_gettime(CLOCK_REALTIME, &time_end);
213 
214         mperf_get_tsc(&dbg);
215         dprint("TSC diff: %llu\n", dbg - tsc_at_measure_end);
216 
217         return 0;
218 }
219 
220 /*
221  * Mperf register is defined to tick at P0 (maximum) frequency
222  *
223  * Instead of reading out P0 which can be tricky to read out from HW,
224  * we use TSC counter if it reliably ticks at P0/mperf frequency.
225  *
226  * Still try to fall back to:
227  * /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq
228  * on older Intel HW without invariant TSC feature.
229  * Or on AMD machines where TSC does not tick at P0 (do not exist yet, but
230  * it's still double checked (MSR_AMD_HWCR)).
231  *
232  * On these machines the user would still get useful mperf
233  * stats when acpi-cpufreq driver is loaded.
234  */
235 static int init_maxfreq_mode(void)
236 {
237         int ret;
238         unsigned long long hwcr;
239         unsigned long min;
240 
241         if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_INV_TSC))
242                 goto use_sysfs;
243 
244         if (cpupower_cpu_info.vendor == X86_VENDOR_AMD ||
245             cpupower_cpu_info.vendor == X86_VENDOR_HYGON) {
246                 /* MSR_AMD_HWCR tells us whether TSC runs at P0/mperf
247                  * freq.
248                  * A test whether hwcr is accessable/available would be:
249                  * (cpupower_cpu_info.family > 0x10 ||
250                  *   cpupower_cpu_info.family == 0x10 &&
251                  *   cpupower_cpu_info.model >= 0x2))
252                  * This should be the case for all aperf/mperf
253                  * capable AMD machines and is therefore safe to test here.
254                  * Compare with Linus kernel git commit: acf01734b1747b1ec4
255                  */
256                 ret = read_msr(0, MSR_AMD_HWCR, &hwcr);
257                 /*
258                  * If the MSR read failed, assume a Xen system that did
259                  * not explicitly provide access to it and assume TSC works
260                 */
261                 if (ret != 0) {
262                         dprint("TSC read 0x%x failed - assume TSC working\n",
263                                MSR_AMD_HWCR);
264                         return 0;
265                 } else if (1 & (hwcr >> 24)) {
266                         max_freq_mode = MAX_FREQ_TSC_REF;
267                         return 0;
268                 } else { /* Use sysfs max frequency if available */ }
269         } else if (cpupower_cpu_info.vendor == X86_VENDOR_INTEL) {
270                 /*
271                  * On Intel we assume mperf (in C0) is ticking at same
272                  * rate than TSC
273                  */
274                 max_freq_mode = MAX_FREQ_TSC_REF;
275                 return 0;
276         }
277 use_sysfs:
278         if (cpufreq_get_hardware_limits(0, &min, &max_frequency)) {
279                 dprint("Cannot retrieve max freq from cpufreq kernel "
280                        "subsystem\n");
281                 return -1;
282         }
283         max_freq_mode = MAX_FREQ_SYSFS;
284         max_frequency /= 1000; /* Default automatically to MHz value */
285         return 0;
286 }
287 
288 /*
289  * This monitor provides:
290  *
291  * 1) Average frequency a CPU resided in
292  *    This always works if the CPU has aperf/mperf capabilities
293  *
294  * 2) C0 and Cx (any sleep state) time a CPU resided in
295  *    Works if mperf timer stops ticking in sleep states which
296  *    seem to be the case on all current HW.
297  * Both is directly retrieved from HW registers and is independent
298  * from kernel statistics.
299  */
300 struct cpuidle_monitor mperf_monitor;
301 struct cpuidle_monitor *mperf_register(void)
302 {
303         if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_APERF))
304                 return NULL;
305 
306         if (init_maxfreq_mode())
307                 return NULL;
308 
309         /* Free this at program termination */
310         is_valid = calloc(cpu_count, sizeof(int));
311         mperf_previous_count = calloc(cpu_count, sizeof(unsigned long long));
312         aperf_previous_count = calloc(cpu_count, sizeof(unsigned long long));
313         mperf_current_count = calloc(cpu_count, sizeof(unsigned long long));
314         aperf_current_count = calloc(cpu_count, sizeof(unsigned long long));
315 
316         mperf_monitor.name_len = strlen(mperf_monitor.name);
317         return &mperf_monitor;
318 }
319 
320 void mperf_unregister(void)
321 {
322         free(mperf_previous_count);
323         free(aperf_previous_count);
324         free(mperf_current_count);
325         free(aperf_current_count);
326         free(is_valid);
327 }
328 
329 struct cpuidle_monitor mperf_monitor = {
330         .name                   = "Mperf",
331         .hw_states_num          = MPERF_CSTATE_COUNT,
332         .hw_states              = mperf_cstates,
333         .start                  = mperf_start,
334         .stop                   = mperf_stop,
335         .do_register            = mperf_register,
336         .unregister             = mperf_unregister,
337         .needs_root             = 1,
338         .overflow_s             = 922000000 /* 922337203 seconds TSC overflow
339                                                at 20GHz */
340 };
341 #endif /* #if defined(__i386__) || defined(__x86_64__) */
342 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp