1
2
3
4
5
6#if defined(__i386__) || defined(__x86_64__)
7
8#include <stdio.h>
9#include <stdint.h>
10#include <stdlib.h>
11#include <string.h>
12#include <limits.h>
13
14#include <cpufreq.h>
15
16#include "helpers/helpers.h"
17#include "idle_monitor/cpupower-monitor.h"
18
19#define MSR_APERF 0xE8
20#define MSR_MPERF 0xE7
21
22#define MSR_TSC 0x10
23
24#define MSR_AMD_HWCR 0xc0010015
25
26enum mperf_id { C0 = 0, Cx, AVG_FREQ, MPERF_CSTATE_COUNT };
27
28static int mperf_get_count_percent(unsigned int self_id, double *percent,
29 unsigned int cpu);
30static int mperf_get_count_freq(unsigned int id, unsigned long long *count,
31 unsigned int cpu);
32static struct timespec time_start, time_end;
33
34static cstate_t mperf_cstates[MPERF_CSTATE_COUNT] = {
35 {
36 .name = "C0",
37 .desc = N_("Processor Core not idle"),
38 .id = C0,
39 .range = RANGE_THREAD,
40 .get_count_percent = mperf_get_count_percent,
41 },
42 {
43 .name = "Cx",
44 .desc = N_("Processor Core in an idle state"),
45 .id = Cx,
46 .range = RANGE_THREAD,
47 .get_count_percent = mperf_get_count_percent,
48 },
49
50 {
51 .name = "Freq",
52 .desc = N_("Average Frequency (including boost) in MHz"),
53 .id = AVG_FREQ,
54 .range = RANGE_THREAD,
55 .get_count = mperf_get_count_freq,
56 },
57};
58
59enum MAX_FREQ_MODE { MAX_FREQ_SYSFS, MAX_FREQ_TSC_REF };
60static int max_freq_mode;
61
62
63
64
65
66
67static unsigned long max_frequency;
68
69static unsigned long long tsc_at_measure_start;
70static unsigned long long tsc_at_measure_end;
71static unsigned long long *mperf_previous_count;
72static unsigned long long *aperf_previous_count;
73static unsigned long long *mperf_current_count;
74static unsigned long long *aperf_current_count;
75
76
77static int *is_valid;
78
79static int mperf_get_tsc(unsigned long long *tsc)
80{
81 int ret;
82
83 ret = read_msr(base_cpu, MSR_TSC, tsc);
84 if (ret)
85 dprint("Reading TSC MSR failed, returning %llu\n", *tsc);
86 return ret;
87}
88
89static int mperf_init_stats(unsigned int cpu)
90{
91 unsigned long long val;
92 int ret;
93
94 ret = read_msr(cpu, MSR_APERF, &val);
95 aperf_previous_count[cpu] = val;
96 ret |= read_msr(cpu, MSR_MPERF, &val);
97 mperf_previous_count[cpu] = val;
98 is_valid[cpu] = !ret;
99
100 return 0;
101}
102
103static int mperf_measure_stats(unsigned int cpu)
104{
105 unsigned long long val;
106 int ret;
107
108 ret = read_msr(cpu, MSR_APERF, &val);
109 aperf_current_count[cpu] = val;
110 ret |= read_msr(cpu, MSR_MPERF, &val);
111 mperf_current_count[cpu] = val;
112 is_valid[cpu] = !ret;
113
114 return 0;
115}
116
117static int mperf_get_count_percent(unsigned int id, double *percent,
118 unsigned int cpu)
119{
120 unsigned long long aperf_diff, mperf_diff, tsc_diff;
121 unsigned long long timediff;
122
123 if (!is_valid[cpu])
124 return -1;
125
126 if (id != C0 && id != Cx)
127 return -1;
128
129 mperf_diff = mperf_current_count[cpu] - mperf_previous_count[cpu];
130 aperf_diff = aperf_current_count[cpu] - aperf_previous_count[cpu];
131
132 if (max_freq_mode == MAX_FREQ_TSC_REF) {
133 tsc_diff = tsc_at_measure_end - tsc_at_measure_start;
134 *percent = 100.0 * mperf_diff / tsc_diff;
135 dprint("%s: TSC Ref - mperf_diff: %llu, tsc_diff: %llu\n",
136 mperf_cstates[id].name, mperf_diff, tsc_diff);
137 } else if (max_freq_mode == MAX_FREQ_SYSFS) {
138 timediff = max_frequency * timespec_diff_us(time_start, time_end);
139 *percent = 100.0 * mperf_diff / timediff;
140 dprint("%s: MAXFREQ - mperf_diff: %llu, time_diff: %llu\n",
141 mperf_cstates[id].name, mperf_diff, timediff);
142 } else
143 return -1;
144
145 if (id == Cx)
146 *percent = 100.0 - *percent;
147
148 dprint("%s: previous: %llu - current: %llu - (%u)\n",
149 mperf_cstates[id].name, mperf_diff, aperf_diff, cpu);
150 dprint("%s: %f\n", mperf_cstates[id].name, *percent);
151 return 0;
152}
153
154static int mperf_get_count_freq(unsigned int id, unsigned long long *count,
155 unsigned int cpu)
156{
157 unsigned long long aperf_diff, mperf_diff, time_diff, tsc_diff;
158
159 if (id != AVG_FREQ)
160 return 1;
161
162 if (!is_valid[cpu])
163 return -1;
164
165 mperf_diff = mperf_current_count[cpu] - mperf_previous_count[cpu];
166 aperf_diff = aperf_current_count[cpu] - aperf_previous_count[cpu];
167
168 if (max_freq_mode == MAX_FREQ_TSC_REF) {
169
170 tsc_diff = tsc_at_measure_end - tsc_at_measure_start;
171 time_diff = timespec_diff_us(time_start, time_end);
172 max_frequency = tsc_diff / time_diff;
173 }
174
175 *count = max_frequency * ((double)aperf_diff / mperf_diff);
176 dprint("%s: Average freq based on %s maximum frequency:\n",
177 mperf_cstates[id].name,
178 (max_freq_mode == MAX_FREQ_TSC_REF) ? "TSC calculated" : "sysfs read");
179 dprint("max_frequency: %lu\n", max_frequency);
180 dprint("aperf_diff: %llu\n", aperf_diff);
181 dprint("mperf_diff: %llu\n", mperf_diff);
182 dprint("avg freq: %llu\n", *count);
183 return 0;
184}
185
186static int mperf_start(void)
187{
188 int cpu;
189 unsigned long long dbg;
190
191 clock_gettime(CLOCK_REALTIME, &time_start);
192 mperf_get_tsc(&tsc_at_measure_start);
193
194 for (cpu = 0; cpu < cpu_count; cpu++)
195 mperf_init_stats(cpu);
196
197 mperf_get_tsc(&dbg);
198 dprint("TSC diff: %llu\n", dbg - tsc_at_measure_start);
199 return 0;
200}
201
202static int mperf_stop(void)
203{
204 unsigned long long dbg;
205 int cpu;
206
207 for (cpu = 0; cpu < cpu_count; cpu++)
208 mperf_measure_stats(cpu);
209
210 mperf_get_tsc(&tsc_at_measure_end);
211 clock_gettime(CLOCK_REALTIME, &time_end);
212
213 mperf_get_tsc(&dbg);
214 dprint("TSC diff: %llu\n", dbg - tsc_at_measure_end);
215
216 return 0;
217}
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234static int init_maxfreq_mode(void)
235{
236 int ret;
237 unsigned long long hwcr;
238 unsigned long min;
239
240 if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_INV_TSC))
241 goto use_sysfs;
242
243 if (cpupower_cpu_info.vendor == X86_VENDOR_AMD ||
244 cpupower_cpu_info.vendor == X86_VENDOR_HYGON) {
245
246
247
248
249
250
251
252
253
254
255 ret = read_msr(0, MSR_AMD_HWCR, &hwcr);
256
257
258
259
260 if (ret != 0) {
261 dprint("TSC read 0x%x failed - assume TSC working\n",
262 MSR_AMD_HWCR);
263 return 0;
264 } else if (1 & (hwcr >> 24)) {
265 max_freq_mode = MAX_FREQ_TSC_REF;
266 return 0;
267 } else { }
268 } else if (cpupower_cpu_info.vendor == X86_VENDOR_INTEL) {
269
270
271
272
273 max_freq_mode = MAX_FREQ_TSC_REF;
274 return 0;
275 }
276use_sysfs:
277 if (cpufreq_get_hardware_limits(0, &min, &max_frequency)) {
278 dprint("Cannot retrieve max freq from cpufreq kernel "
279 "subsystem\n");
280 return -1;
281 }
282 max_freq_mode = MAX_FREQ_SYSFS;
283 max_frequency /= 1000;
284 return 0;
285}
286
287
288
289
290
291
292
293
294
295
296
297
298
299struct cpuidle_monitor mperf_monitor;
300struct cpuidle_monitor *mperf_register(void)
301{
302 if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_APERF))
303 return NULL;
304
305 if (init_maxfreq_mode())
306 return NULL;
307
308
309 is_valid = calloc(cpu_count, sizeof(int));
310 mperf_previous_count = calloc(cpu_count, sizeof(unsigned long long));
311 aperf_previous_count = calloc(cpu_count, sizeof(unsigned long long));
312 mperf_current_count = calloc(cpu_count, sizeof(unsigned long long));
313 aperf_current_count = calloc(cpu_count, sizeof(unsigned long long));
314
315 mperf_monitor.name_len = strlen(mperf_monitor.name);
316 return &mperf_monitor;
317}
318
319void mperf_unregister(void)
320{
321 free(mperf_previous_count);
322 free(aperf_previous_count);
323 free(mperf_current_count);
324 free(aperf_current_count);
325 free(is_valid);
326}
327
328struct cpuidle_monitor mperf_monitor = {
329 .name = "Mperf",
330 .hw_states_num = MPERF_CSTATE_COUNT,
331 .hw_states = mperf_cstates,
332 .start = mperf_start,
333 .stop = mperf_stop,
334 .do_register = mperf_register,
335 .unregister = mperf_unregister,
336 .needs_root = 1,
337 .overflow_s = 922000000
338
339};
340#endif
341