xref: /openbmc/linux/tools/power/x86/turbostat/turbostat.c (revision a729617c58529be0be8faa22c5d45748bb0f12e5)
1103a8feaSLen Brown /*
2103a8feaSLen Brown  * turbostat -- show CPU frequency and C-state residency
3103a8feaSLen Brown  * on modern Intel turbo-capable processors.
4103a8feaSLen Brown  *
5144b44b1SLen Brown  * Copyright (c) 2013 Intel Corporation.
6103a8feaSLen Brown  * Len Brown <len.brown@intel.com>
7103a8feaSLen Brown  *
8103a8feaSLen Brown  * This program is free software; you can redistribute it and/or modify it
9103a8feaSLen Brown  * under the terms and conditions of the GNU General Public License,
10103a8feaSLen Brown  * version 2, as published by the Free Software Foundation.
11103a8feaSLen Brown  *
12103a8feaSLen Brown  * This program is distributed in the hope it will be useful, but WITHOUT
13103a8feaSLen Brown  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14103a8feaSLen Brown  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
15103a8feaSLen Brown  * more details.
16103a8feaSLen Brown  *
17103a8feaSLen Brown  * You should have received a copy of the GNU General Public License along with
18103a8feaSLen Brown  * this program; if not, write to the Free Software Foundation, Inc.,
19103a8feaSLen Brown  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
20103a8feaSLen Brown  */
21103a8feaSLen Brown 
2288c3281fSLen Brown #define _GNU_SOURCE
23b731f311SJosh Triplett #include MSRHEADER
2495aebc44SJosh Triplett #include <stdarg.h>
25103a8feaSLen Brown #include <stdio.h>
26b2c95d90SJosh Triplett #include <err.h>
27103a8feaSLen Brown #include <unistd.h>
28103a8feaSLen Brown #include <sys/types.h>
29103a8feaSLen Brown #include <sys/wait.h>
30103a8feaSLen Brown #include <sys/stat.h>
31103a8feaSLen Brown #include <sys/resource.h>
32103a8feaSLen Brown #include <fcntl.h>
33103a8feaSLen Brown #include <signal.h>
34103a8feaSLen Brown #include <sys/time.h>
35103a8feaSLen Brown #include <stdlib.h>
36103a8feaSLen Brown #include <dirent.h>
37103a8feaSLen Brown #include <string.h>
38103a8feaSLen Brown #include <ctype.h>
3988c3281fSLen Brown #include <sched.h>
402b92865eSJosh Triplett #include <cpuid.h>
4198481e79SLen Brown #include <linux/capability.h>
4298481e79SLen Brown #include <errno.h>
43103a8feaSLen Brown 
44103a8feaSLen Brown char *proc_stat = "/proc/stat";
45103a8feaSLen Brown unsigned int interval_sec = 5;	/* set with -i interval_sec */
46103a8feaSLen Brown unsigned int verbose;		/* set with -v */
47889facbeSLen Brown unsigned int rapl_verbose;	/* set with -R */
485c56be9aSDirk Brandewie unsigned int rapl_joules;	/* set with -J */
49889facbeSLen Brown unsigned int thermal_verbose;	/* set with -T */
50f591c38bSAndy Shevchenko unsigned int summary_only;	/* set with -S */
513b4d5c7fSAndy Shevchenko unsigned int dump_only;		/* set with -s */
52103a8feaSLen Brown unsigned int skip_c0;
53103a8feaSLen Brown unsigned int skip_c1;
54103a8feaSLen Brown unsigned int do_nhm_cstates;
55103a8feaSLen Brown unsigned int do_snb_cstates;
56ca58710fSKristen Carlson Accardi unsigned int do_c8_c9_c10;
57144b44b1SLen Brown unsigned int do_slm_cstates;
58144b44b1SLen Brown unsigned int use_c1_residency_msr;
59103a8feaSLen Brown unsigned int has_aperf;
60889facbeSLen Brown unsigned int has_epb;
61fc04cc67SLen Brown unsigned int units = 1000000;	/* MHz etc */
62103a8feaSLen Brown unsigned int genuine_intel;
63103a8feaSLen Brown unsigned int has_invariant_tsc;
64d7899447SLen Brown unsigned int do_nhm_platform_info;
65d7899447SLen Brown unsigned int do_nhm_turbo_ratio_limit;
666574a5d5SLen Brown unsigned int do_ivt_turbo_ratio_limit;
672f32edf1SLen Brown unsigned int extra_msr_offset32;
682f32edf1SLen Brown unsigned int extra_msr_offset64;
698e180f3cSLen Brown unsigned int extra_delta_offset32;
708e180f3cSLen Brown unsigned int extra_delta_offset64;
711ed51011SLen Brown int do_smi;
72103a8feaSLen Brown double bclk;
73103a8feaSLen Brown unsigned int show_pkg;
74103a8feaSLen Brown unsigned int show_core;
75103a8feaSLen Brown unsigned int show_cpu;
76c98d5d94SLen Brown unsigned int show_pkg_only;
77c98d5d94SLen Brown unsigned int show_core_only;
78c98d5d94SLen Brown char *output_buffer, *outp;
79889facbeSLen Brown unsigned int do_rapl;
80889facbeSLen Brown unsigned int do_dts;
81889facbeSLen Brown unsigned int do_ptm;
82889facbeSLen Brown unsigned int tcc_activation_temp;
83889facbeSLen Brown unsigned int tcc_activation_temp_override;
84889facbeSLen Brown double rapl_power_units, rapl_energy_units, rapl_time_units;
85889facbeSLen Brown double rapl_joule_counter_range;
863a9a941dSLen Brown unsigned int do_core_perf_limit_reasons;
873a9a941dSLen Brown unsigned int do_gfx_perf_limit_reasons;
883a9a941dSLen Brown unsigned int do_ring_perf_limit_reasons;
89889facbeSLen Brown 
90889facbeSLen Brown #define RAPL_PKG		(1 << 0)
91e6f9bb3cSLen Brown 					/* 0x610 MSR_PKG_POWER_LIMIT */
92e6f9bb3cSLen Brown 					/* 0x611 MSR_PKG_ENERGY_STATUS */
93e6f9bb3cSLen Brown #define RAPL_PKG_PERF_STATUS	(1 << 1)
94e6f9bb3cSLen Brown 					/* 0x613 MSR_PKG_PERF_STATUS */
95e6f9bb3cSLen Brown #define RAPL_PKG_POWER_INFO	(1 << 2)
96e6f9bb3cSLen Brown 					/* 0x614 MSR_PKG_POWER_INFO */
97e6f9bb3cSLen Brown 
98889facbeSLen Brown #define RAPL_DRAM		(1 << 3)
99e6f9bb3cSLen Brown 					/* 0x618 MSR_DRAM_POWER_LIMIT */
100e6f9bb3cSLen Brown 					/* 0x619 MSR_DRAM_ENERGY_STATUS */
101e6f9bb3cSLen Brown 					/* 0x61c MSR_DRAM_POWER_INFO */
102e6f9bb3cSLen Brown #define RAPL_DRAM_PERF_STATUS	(1 << 4)
103e6f9bb3cSLen Brown 					/* 0x61b MSR_DRAM_PERF_STATUS */
104e6f9bb3cSLen Brown 
105e6f9bb3cSLen Brown #define RAPL_CORES		(1 << 5)
106e6f9bb3cSLen Brown 					/* 0x638 MSR_PP0_POWER_LIMIT */
107e6f9bb3cSLen Brown 					/* 0x639 MSR_PP0_ENERGY_STATUS */
108e6f9bb3cSLen Brown #define RAPL_CORE_POLICY	(1 << 6)
109e6f9bb3cSLen Brown 					/* 0x63a MSR_PP0_POLICY */
110e6f9bb3cSLen Brown 
111e6f9bb3cSLen Brown 
112e6f9bb3cSLen Brown #define RAPL_GFX		(1 << 7)
113e6f9bb3cSLen Brown 					/* 0x640 MSR_PP1_POWER_LIMIT */
114e6f9bb3cSLen Brown 					/* 0x641 MSR_PP1_ENERGY_STATUS */
115e6f9bb3cSLen Brown 					/* 0x642 MSR_PP1_POLICY */
116889facbeSLen Brown #define	TJMAX_DEFAULT	100
117889facbeSLen Brown 
118889facbeSLen Brown #define MAX(a, b) ((a) > (b) ? (a) : (b))
119103a8feaSLen Brown 
120103a8feaSLen Brown int aperf_mperf_unstable;
121103a8feaSLen Brown int backwards_count;
122103a8feaSLen Brown char *progname;
123103a8feaSLen Brown 
124c98d5d94SLen Brown cpu_set_t *cpu_present_set, *cpu_affinity_set;
125c98d5d94SLen Brown size_t cpu_present_setsize, cpu_affinity_setsize;
126c98d5d94SLen Brown 
127c98d5d94SLen Brown struct thread_data {
128c98d5d94SLen Brown 	unsigned long long tsc;
129c98d5d94SLen Brown 	unsigned long long aperf;
130c98d5d94SLen Brown 	unsigned long long mperf;
131144b44b1SLen Brown 	unsigned long long c1;
1322f32edf1SLen Brown 	unsigned long long extra_msr64;
1338e180f3cSLen Brown 	unsigned long long extra_delta64;
1348e180f3cSLen Brown 	unsigned long long extra_msr32;
1358e180f3cSLen Brown 	unsigned long long extra_delta32;
1361ed51011SLen Brown 	unsigned int smi_count;
137c98d5d94SLen Brown 	unsigned int cpu_id;
138c98d5d94SLen Brown 	unsigned int flags;
139c98d5d94SLen Brown #define CPU_IS_FIRST_THREAD_IN_CORE	0x2
140c98d5d94SLen Brown #define CPU_IS_FIRST_CORE_IN_PACKAGE	0x4
141c98d5d94SLen Brown } *thread_even, *thread_odd;
142c98d5d94SLen Brown 
143c98d5d94SLen Brown struct core_data {
144c98d5d94SLen Brown 	unsigned long long c3;
145c98d5d94SLen Brown 	unsigned long long c6;
146c98d5d94SLen Brown 	unsigned long long c7;
147889facbeSLen Brown 	unsigned int core_temp_c;
148c98d5d94SLen Brown 	unsigned int core_id;
149c98d5d94SLen Brown } *core_even, *core_odd;
150c98d5d94SLen Brown 
151c98d5d94SLen Brown struct pkg_data {
152c98d5d94SLen Brown 	unsigned long long pc2;
153c98d5d94SLen Brown 	unsigned long long pc3;
154c98d5d94SLen Brown 	unsigned long long pc6;
155c98d5d94SLen Brown 	unsigned long long pc7;
156ca58710fSKristen Carlson Accardi 	unsigned long long pc8;
157ca58710fSKristen Carlson Accardi 	unsigned long long pc9;
158ca58710fSKristen Carlson Accardi 	unsigned long long pc10;
159c98d5d94SLen Brown 	unsigned int package_id;
160889facbeSLen Brown 	unsigned int energy_pkg;	/* MSR_PKG_ENERGY_STATUS */
161889facbeSLen Brown 	unsigned int energy_dram;	/* MSR_DRAM_ENERGY_STATUS */
162889facbeSLen Brown 	unsigned int energy_cores;	/* MSR_PP0_ENERGY_STATUS */
163889facbeSLen Brown 	unsigned int energy_gfx;	/* MSR_PP1_ENERGY_STATUS */
164889facbeSLen Brown 	unsigned int rapl_pkg_perf_status;	/* MSR_PKG_PERF_STATUS */
165889facbeSLen Brown 	unsigned int rapl_dram_perf_status;	/* MSR_DRAM_PERF_STATUS */
166889facbeSLen Brown 	unsigned int pkg_temp_c;
167889facbeSLen Brown 
168c98d5d94SLen Brown } *package_even, *package_odd;
169c98d5d94SLen Brown 
170c98d5d94SLen Brown #define ODD_COUNTERS thread_odd, core_odd, package_odd
171c98d5d94SLen Brown #define EVEN_COUNTERS thread_even, core_even, package_even
172c98d5d94SLen Brown 
173c98d5d94SLen Brown #define GET_THREAD(thread_base, thread_no, core_no, pkg_no) \
174c98d5d94SLen Brown 	(thread_base + (pkg_no) * topo.num_cores_per_pkg * \
175c98d5d94SLen Brown 		topo.num_threads_per_core + \
176c98d5d94SLen Brown 		(core_no) * topo.num_threads_per_core + (thread_no))
177c98d5d94SLen Brown #define GET_CORE(core_base, core_no, pkg_no) \
178c98d5d94SLen Brown 	(core_base + (pkg_no) * topo.num_cores_per_pkg + (core_no))
179c98d5d94SLen Brown #define GET_PKG(pkg_base, pkg_no) (pkg_base + pkg_no)
180c98d5d94SLen Brown 
181c98d5d94SLen Brown struct system_summary {
182c98d5d94SLen Brown 	struct thread_data threads;
183c98d5d94SLen Brown 	struct core_data cores;
184c98d5d94SLen Brown 	struct pkg_data packages;
185c98d5d94SLen Brown } sum, average;
186c98d5d94SLen Brown 
187c98d5d94SLen Brown 
188c98d5d94SLen Brown struct topo_params {
189c98d5d94SLen Brown 	int num_packages;
190103a8feaSLen Brown 	int num_cpus;
191c98d5d94SLen Brown 	int num_cores;
192c98d5d94SLen Brown 	int max_cpu_num;
193c98d5d94SLen Brown 	int num_cores_per_pkg;
194c98d5d94SLen Brown 	int num_threads_per_core;
195c98d5d94SLen Brown } topo;
196103a8feaSLen Brown 
197c98d5d94SLen Brown struct timeval tv_even, tv_odd, tv_delta;
198103a8feaSLen Brown 
199c98d5d94SLen Brown void setup_all_buffers(void);
200103a8feaSLen Brown 
201c98d5d94SLen Brown int cpu_is_not_present(int cpu)
202d15cf7c1SLen Brown {
203c98d5d94SLen Brown 	return !CPU_ISSET_S(cpu, cpu_present_setsize, cpu_present_set);
204c98d5d94SLen Brown }
205c98d5d94SLen Brown /*
206c98d5d94SLen Brown  * run func(thread, core, package) in topology order
207c98d5d94SLen Brown  * skip non-present cpus
208c98d5d94SLen Brown  */
209c98d5d94SLen Brown 
210c98d5d94SLen Brown int for_all_cpus(int (func)(struct thread_data *, struct core_data *, struct pkg_data *),
211c98d5d94SLen Brown 	struct thread_data *thread_base, struct core_data *core_base, struct pkg_data *pkg_base)
212c98d5d94SLen Brown {
213c98d5d94SLen Brown 	int retval, pkg_no, core_no, thread_no;
214c98d5d94SLen Brown 
215c98d5d94SLen Brown 	for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
216c98d5d94SLen Brown 		for (core_no = 0; core_no < topo.num_cores_per_pkg; ++core_no) {
217c98d5d94SLen Brown 			for (thread_no = 0; thread_no <
218c98d5d94SLen Brown 				topo.num_threads_per_core; ++thread_no) {
219c98d5d94SLen Brown 				struct thread_data *t;
220c98d5d94SLen Brown 				struct core_data *c;
221c98d5d94SLen Brown 				struct pkg_data *p;
222c98d5d94SLen Brown 
223c98d5d94SLen Brown 				t = GET_THREAD(thread_base, thread_no, core_no, pkg_no);
224c98d5d94SLen Brown 
225c98d5d94SLen Brown 				if (cpu_is_not_present(t->cpu_id))
226c98d5d94SLen Brown 					continue;
227c98d5d94SLen Brown 
228c98d5d94SLen Brown 				c = GET_CORE(core_base, core_no, pkg_no);
229c98d5d94SLen Brown 				p = GET_PKG(pkg_base, pkg_no);
230c98d5d94SLen Brown 
231c98d5d94SLen Brown 				retval = func(t, c, p);
232c98d5d94SLen Brown 				if (retval)
233c98d5d94SLen Brown 					return retval;
234c98d5d94SLen Brown 			}
235c98d5d94SLen Brown 		}
236c98d5d94SLen Brown 	}
237d15cf7c1SLen Brown 	return 0;
238d15cf7c1SLen Brown }
239d15cf7c1SLen Brown 
24088c3281fSLen Brown int cpu_migrate(int cpu)
24188c3281fSLen Brown {
242c98d5d94SLen Brown 	CPU_ZERO_S(cpu_affinity_setsize, cpu_affinity_set);
243c98d5d94SLen Brown 	CPU_SET_S(cpu, cpu_affinity_setsize, cpu_affinity_set);
244c98d5d94SLen Brown 	if (sched_setaffinity(0, cpu_affinity_setsize, cpu_affinity_set) == -1)
24588c3281fSLen Brown 		return -1;
24688c3281fSLen Brown 	else
24788c3281fSLen Brown 		return 0;
24888c3281fSLen Brown }
24988c3281fSLen Brown 
25015aaa346SLen Brown int get_msr(int cpu, off_t offset, unsigned long long *msr)
251103a8feaSLen Brown {
252103a8feaSLen Brown 	ssize_t retval;
253103a8feaSLen Brown 	char pathname[32];
254103a8feaSLen Brown 	int fd;
255103a8feaSLen Brown 
256103a8feaSLen Brown 	sprintf(pathname, "/dev/cpu/%d/msr", cpu);
257103a8feaSLen Brown 	fd = open(pathname, O_RDONLY);
25815aaa346SLen Brown 	if (fd < 0)
25998481e79SLen Brown 		err(-1, "%s open failed, try chown or chmod +r /dev/cpu/*/msr, or run as root", pathname);
260103a8feaSLen Brown 
26115aaa346SLen Brown 	retval = pread(fd, msr, sizeof *msr, offset);
262103a8feaSLen Brown 	close(fd);
26315aaa346SLen Brown 
26498481e79SLen Brown 	if (retval != sizeof *msr)
26598481e79SLen Brown 		err(-1, "%s offset 0x%llx read failed", pathname, (unsigned long long)offset);
26615aaa346SLen Brown 
26715aaa346SLen Brown 	return 0;
268103a8feaSLen Brown }
269103a8feaSLen Brown 
270fc04cc67SLen Brown /*
271fc04cc67SLen Brown  * Example Format w/ field column widths:
272fc04cc67SLen Brown  *
273fc04cc67SLen Brown  *  Package    Core     CPU Avg_MHz Bzy_MHz TSC_MHz     SMI   %Busy CPU_%c1 CPU_%c3 CPU_%c6 CPU_%c7 CoreTmp  PkgTmp Pkg%pc2 Pkg%pc3 Pkg%pc6 Pkg%pc7 PkgWatt CorWatt GFXWatt
274e7c95ff3SLen Brown  * 123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678
275fc04cc67SLen Brown  */
276fc04cc67SLen Brown 
277a829eb4dSLen Brown void print_header(void)
278103a8feaSLen Brown {
279103a8feaSLen Brown 	if (show_pkg)
280fc04cc67SLen Brown 		outp += sprintf(outp, " Package");
281103a8feaSLen Brown 	if (show_core)
282fc04cc67SLen Brown 		outp += sprintf(outp, "    Core");
283103a8feaSLen Brown 	if (show_cpu)
284c98d5d94SLen Brown 		outp += sprintf(outp, "     CPU");
285103a8feaSLen Brown 	if (has_aperf)
286fc04cc67SLen Brown 		outp += sprintf(outp, " Avg_MHz");
287d7899447SLen Brown 	if (has_aperf)
288fc04cc67SLen Brown 		outp += sprintf(outp, "   %%Busy");
289fc04cc67SLen Brown 	if (has_aperf)
290fc04cc67SLen Brown 		outp += sprintf(outp, " Bzy_MHz");
291fc04cc67SLen Brown 	outp += sprintf(outp, " TSC_MHz");
2921ed51011SLen Brown 	if (do_smi)
2931ed51011SLen Brown 		outp += sprintf(outp, "     SMI");
2948e180f3cSLen Brown 	if (extra_delta_offset32)
295f9240813SLen Brown 		outp += sprintf(outp, "  count 0x%03X", extra_delta_offset32);
2968e180f3cSLen Brown 	if (extra_delta_offset64)
297f9240813SLen Brown 		outp += sprintf(outp, "  COUNT 0x%03X", extra_delta_offset64);
2982f32edf1SLen Brown 	if (extra_msr_offset32)
2998e180f3cSLen Brown 		outp += sprintf(outp, "   MSR 0x%03X", extra_msr_offset32);
3002f32edf1SLen Brown 	if (extra_msr_offset64)
3018e180f3cSLen Brown 		outp += sprintf(outp, "           MSR 0x%03X", extra_msr_offset64);
302103a8feaSLen Brown 	if (do_nhm_cstates)
303fc04cc67SLen Brown 		outp += sprintf(outp, "  CPU%%c1");
304144b44b1SLen Brown 	if (do_nhm_cstates && !do_slm_cstates)
305fc04cc67SLen Brown 		outp += sprintf(outp, "  CPU%%c3");
306103a8feaSLen Brown 	if (do_nhm_cstates)
307fc04cc67SLen Brown 		outp += sprintf(outp, "  CPU%%c6");
308103a8feaSLen Brown 	if (do_snb_cstates)
309fc04cc67SLen Brown 		outp += sprintf(outp, "  CPU%%c7");
310889facbeSLen Brown 
311889facbeSLen Brown 	if (do_dts)
312fc04cc67SLen Brown 		outp += sprintf(outp, " CoreTmp");
313889facbeSLen Brown 	if (do_ptm)
314fc04cc67SLen Brown 		outp += sprintf(outp, "  PkgTmp");
315889facbeSLen Brown 
316103a8feaSLen Brown 	if (do_snb_cstates)
317fc04cc67SLen Brown 		outp += sprintf(outp, " Pkg%%pc2");
318144b44b1SLen Brown 	if (do_nhm_cstates && !do_slm_cstates)
319fc04cc67SLen Brown 		outp += sprintf(outp, " Pkg%%pc3");
320144b44b1SLen Brown 	if (do_nhm_cstates && !do_slm_cstates)
321fc04cc67SLen Brown 		outp += sprintf(outp, " Pkg%%pc6");
322103a8feaSLen Brown 	if (do_snb_cstates)
323fc04cc67SLen Brown 		outp += sprintf(outp, " Pkg%%pc7");
324ca58710fSKristen Carlson Accardi 	if (do_c8_c9_c10) {
325fc04cc67SLen Brown 		outp += sprintf(outp, " Pkg%%pc8");
326fc04cc67SLen Brown 		outp += sprintf(outp, " Pkg%%pc9");
327fc04cc67SLen Brown 		outp += sprintf(outp, " Pk%%pc10");
328ca58710fSKristen Carlson Accardi 	}
329103a8feaSLen Brown 
3305c56be9aSDirk Brandewie 	if (do_rapl && !rapl_joules) {
331889facbeSLen Brown 		if (do_rapl & RAPL_PKG)
332fc04cc67SLen Brown 			outp += sprintf(outp, " PkgWatt");
333889facbeSLen Brown 		if (do_rapl & RAPL_CORES)
334fc04cc67SLen Brown 			outp += sprintf(outp, " CorWatt");
335889facbeSLen Brown 		if (do_rapl & RAPL_GFX)
336fc04cc67SLen Brown 			outp += sprintf(outp, " GFXWatt");
337889facbeSLen Brown 		if (do_rapl & RAPL_DRAM)
338fc04cc67SLen Brown 			outp += sprintf(outp, " RAMWatt");
339889facbeSLen Brown 		if (do_rapl & RAPL_PKG_PERF_STATUS)
340889facbeSLen Brown 			outp += sprintf(outp, "   PKG_%%");
341889facbeSLen Brown 		if (do_rapl & RAPL_DRAM_PERF_STATUS)
342889facbeSLen Brown 			outp += sprintf(outp, "   RAM_%%");
343d7899447SLen Brown 	} else if (do_rapl && rapl_joules) {
3445c56be9aSDirk Brandewie 		if (do_rapl & RAPL_PKG)
3455c56be9aSDirk Brandewie 			outp += sprintf(outp, "   Pkg_J");
3465c56be9aSDirk Brandewie 		if (do_rapl & RAPL_CORES)
3475c56be9aSDirk Brandewie 			outp += sprintf(outp, "   Cor_J");
3485c56be9aSDirk Brandewie 		if (do_rapl & RAPL_GFX)
3495c56be9aSDirk Brandewie 			outp += sprintf(outp, "   GFX_J");
3505c56be9aSDirk Brandewie 		if (do_rapl & RAPL_DRAM)
3515c56be9aSDirk Brandewie 			outp += sprintf(outp, "   RAM_W");
3525c56be9aSDirk Brandewie 		if (do_rapl & RAPL_PKG_PERF_STATUS)
3535c56be9aSDirk Brandewie 			outp += sprintf(outp, "   PKG_%%");
3545c56be9aSDirk Brandewie 		if (do_rapl & RAPL_DRAM_PERF_STATUS)
3555c56be9aSDirk Brandewie 			outp += sprintf(outp, "   RAM_%%");
3565c56be9aSDirk Brandewie 		outp += sprintf(outp, "   time");
357889facbeSLen Brown 
3585c56be9aSDirk Brandewie 	}
359c98d5d94SLen Brown 	outp += sprintf(outp, "\n");
360103a8feaSLen Brown }
361103a8feaSLen Brown 
362c98d5d94SLen Brown int dump_counters(struct thread_data *t, struct core_data *c,
363c98d5d94SLen Brown 	struct pkg_data *p)
364103a8feaSLen Brown {
3653b4d5c7fSAndy Shevchenko 	outp += sprintf(outp, "t %p, c %p, p %p\n", t, c, p);
366c98d5d94SLen Brown 
367c98d5d94SLen Brown 	if (t) {
3683b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "CPU: %d flags 0x%x\n",
3693b4d5c7fSAndy Shevchenko 			t->cpu_id, t->flags);
3703b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "TSC: %016llX\n", t->tsc);
3713b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "aperf: %016llX\n", t->aperf);
3723b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "mperf: %016llX\n", t->mperf);
3733b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c1: %016llX\n", t->c1);
3743b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "msr0x%x: %08llX\n",
3758e180f3cSLen Brown 			extra_delta_offset32, t->extra_delta32);
3763b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "msr0x%x: %016llX\n",
3778e180f3cSLen Brown 			extra_delta_offset64, t->extra_delta64);
3783b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "msr0x%x: %08llX\n",
3792f32edf1SLen Brown 			extra_msr_offset32, t->extra_msr32);
3803b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "msr0x%x: %016llX\n",
3812f32edf1SLen Brown 			extra_msr_offset64, t->extra_msr64);
3821ed51011SLen Brown 		if (do_smi)
3833b4d5c7fSAndy Shevchenko 			outp += sprintf(outp, "SMI: %08X\n", t->smi_count);
384103a8feaSLen Brown 	}
385103a8feaSLen Brown 
386c98d5d94SLen Brown 	if (c) {
3873b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "core: %d\n", c->core_id);
3883b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c3: %016llX\n", c->c3);
3893b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c6: %016llX\n", c->c6);
3903b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "c7: %016llX\n", c->c7);
3913b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "DTS: %dC\n", c->core_temp_c);
392c98d5d94SLen Brown 	}
393103a8feaSLen Brown 
394c98d5d94SLen Brown 	if (p) {
3953b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "package: %d\n", p->package_id);
3963b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc2: %016llX\n", p->pc2);
3973b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc3: %016llX\n", p->pc3);
3983b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc6: %016llX\n", p->pc6);
3993b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc7: %016llX\n", p->pc7);
4003b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc8: %016llX\n", p->pc8);
4013b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc9: %016llX\n", p->pc9);
4023b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "pc10: %016llX\n", p->pc10);
4033b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules PKG: %0X\n", p->energy_pkg);
4043b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules COR: %0X\n", p->energy_cores);
4053b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules GFX: %0X\n", p->energy_gfx);
4063b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Joules RAM: %0X\n", p->energy_dram);
4073b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Throttle PKG: %0X\n",
4083b4d5c7fSAndy Shevchenko 			p->rapl_pkg_perf_status);
4093b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "Throttle RAM: %0X\n",
4103b4d5c7fSAndy Shevchenko 			p->rapl_dram_perf_status);
4113b4d5c7fSAndy Shevchenko 		outp += sprintf(outp, "PTM: %dC\n", p->pkg_temp_c);
412c98d5d94SLen Brown 	}
4133b4d5c7fSAndy Shevchenko 
4143b4d5c7fSAndy Shevchenko 	outp += sprintf(outp, "\n");
4153b4d5c7fSAndy Shevchenko 
416c98d5d94SLen Brown 	return 0;
417103a8feaSLen Brown }
418103a8feaSLen Brown 
419e23da037SLen Brown /*
420e23da037SLen Brown  * column formatting convention & formats
421e23da037SLen Brown  */
422c98d5d94SLen Brown int format_counters(struct thread_data *t, struct core_data *c,
423c98d5d94SLen Brown 	struct pkg_data *p)
424103a8feaSLen Brown {
425103a8feaSLen Brown 	double interval_float;
426fc04cc67SLen Brown 	char *fmt8;
427103a8feaSLen Brown 
428c98d5d94SLen Brown 	 /* if showing only 1st thread in core and this isn't one, bail out */
429c98d5d94SLen Brown 	if (show_core_only && !(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
430c98d5d94SLen Brown 		return 0;
431c98d5d94SLen Brown 
432c98d5d94SLen Brown 	 /* if showing only 1st thread in pkg and this isn't one, bail out */
433c98d5d94SLen Brown 	if (show_pkg_only && !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
434c98d5d94SLen Brown 		return 0;
435c98d5d94SLen Brown 
436103a8feaSLen Brown 	interval_float = tv_delta.tv_sec + tv_delta.tv_usec/1000000.0;
437103a8feaSLen Brown 
438c98d5d94SLen Brown 	/* topo columns, print blanks on 1st (average) line */
439c98d5d94SLen Brown 	if (t == &average.threads) {
440103a8feaSLen Brown 		if (show_pkg)
441fc04cc67SLen Brown 			outp += sprintf(outp, "       -");
442103a8feaSLen Brown 		if (show_core)
443fc04cc67SLen Brown 			outp += sprintf(outp, "       -");
444103a8feaSLen Brown 		if (show_cpu)
445fc04cc67SLen Brown 			outp += sprintf(outp, "       -");
446103a8feaSLen Brown 	} else {
447c98d5d94SLen Brown 		if (show_pkg) {
448c98d5d94SLen Brown 			if (p)
449fc04cc67SLen Brown 				outp += sprintf(outp, "%8d", p->package_id);
450c98d5d94SLen Brown 			else
451fc04cc67SLen Brown 				outp += sprintf(outp, "       -");
452c98d5d94SLen Brown 		}
453c98d5d94SLen Brown 		if (show_core) {
454c98d5d94SLen Brown 			if (c)
455fc04cc67SLen Brown 				outp += sprintf(outp, "%8d", c->core_id);
456c98d5d94SLen Brown 			else
457fc04cc67SLen Brown 				outp += sprintf(outp, "       -");
458c98d5d94SLen Brown 		}
459103a8feaSLen Brown 		if (show_cpu)
460fc04cc67SLen Brown 			outp += sprintf(outp, "%8d", t->cpu_id);
461103a8feaSLen Brown 	}
462fc04cc67SLen Brown 
463d7899447SLen Brown 	/* Avg_MHz */
464fc04cc67SLen Brown 	if (has_aperf)
465fc04cc67SLen Brown 		outp += sprintf(outp, "%8.0f",
466fc04cc67SLen Brown 			1.0 / units * t->aperf / interval_float);
467fc04cc67SLen Brown 
468d7899447SLen Brown 	/* %Busy */
469d7899447SLen Brown 	if (has_aperf) {
470103a8feaSLen Brown 		if (!skip_c0)
471fc04cc67SLen Brown 			outp += sprintf(outp, "%8.2f", 100.0 * t->mperf/t->tsc);
472103a8feaSLen Brown 		else
473fc04cc67SLen Brown 			outp += sprintf(outp, "********");
474103a8feaSLen Brown 	}
475103a8feaSLen Brown 
476d7899447SLen Brown 	/* Bzy_MHz */
477fc04cc67SLen Brown 	if (has_aperf)
478fc04cc67SLen Brown 		outp += sprintf(outp, "%8.0f",
479fc04cc67SLen Brown 			1.0 * t->tsc / units * t->aperf / t->mperf / interval_float);
480103a8feaSLen Brown 
481d7899447SLen Brown 	/* TSC_MHz */
482fc04cc67SLen Brown 	outp += sprintf(outp, "%8.0f", 1.0 * t->tsc/units/interval_float);
483103a8feaSLen Brown 
4841ed51011SLen Brown 	/* SMI */
4851ed51011SLen Brown 	if (do_smi)
486fc04cc67SLen Brown 		outp += sprintf(outp, "%8d", t->smi_count);
4871ed51011SLen Brown 
4888e180f3cSLen Brown 	/* delta */
4898e180f3cSLen Brown 	if (extra_delta_offset32)
4908e180f3cSLen Brown 		outp += sprintf(outp, "  %11llu", t->extra_delta32);
4918e180f3cSLen Brown 
4928e180f3cSLen Brown 	/* DELTA */
4938e180f3cSLen Brown 	if (extra_delta_offset64)
4948e180f3cSLen Brown 		outp += sprintf(outp, "  %11llu", t->extra_delta64);
4952f32edf1SLen Brown 	/* msr */
4962f32edf1SLen Brown 	if (extra_msr_offset32)
4978e180f3cSLen Brown 		outp += sprintf(outp, "  0x%08llx", t->extra_msr32);
4982f32edf1SLen Brown 
499130ff304SLen Brown 	/* MSR */
5002f32edf1SLen Brown 	if (extra_msr_offset64)
5012f32edf1SLen Brown 		outp += sprintf(outp, "  0x%016llx", t->extra_msr64);
502130ff304SLen Brown 
503103a8feaSLen Brown 	if (do_nhm_cstates) {
504103a8feaSLen Brown 		if (!skip_c1)
505fc04cc67SLen Brown 			outp += sprintf(outp, "%8.2f", 100.0 * t->c1/t->tsc);
506103a8feaSLen Brown 		else
507fc04cc67SLen Brown 			outp += sprintf(outp, "********");
508103a8feaSLen Brown 	}
509c98d5d94SLen Brown 
510c98d5d94SLen Brown 	/* print per-core data only for 1st thread in core */
511c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
512c98d5d94SLen Brown 		goto done;
513c98d5d94SLen Brown 
514144b44b1SLen Brown 	if (do_nhm_cstates && !do_slm_cstates)
515fc04cc67SLen Brown 		outp += sprintf(outp, "%8.2f", 100.0 * c->c3/t->tsc);
516103a8feaSLen Brown 	if (do_nhm_cstates)
517fc04cc67SLen Brown 		outp += sprintf(outp, "%8.2f", 100.0 * c->c6/t->tsc);
518103a8feaSLen Brown 	if (do_snb_cstates)
519fc04cc67SLen Brown 		outp += sprintf(outp, "%8.2f", 100.0 * c->c7/t->tsc);
520c98d5d94SLen Brown 
521889facbeSLen Brown 	if (do_dts)
522fc04cc67SLen Brown 		outp += sprintf(outp, "%8d", c->core_temp_c);
523889facbeSLen Brown 
524c98d5d94SLen Brown 	/* print per-package data only for 1st core in package */
525c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
526c98d5d94SLen Brown 		goto done;
527c98d5d94SLen Brown 
528889facbeSLen Brown 	if (do_ptm)
529fc04cc67SLen Brown 		outp += sprintf(outp, "%8d", p->pkg_temp_c);
530889facbeSLen Brown 
531103a8feaSLen Brown 	if (do_snb_cstates)
532fc04cc67SLen Brown 		outp += sprintf(outp, "%8.2f", 100.0 * p->pc2/t->tsc);
533144b44b1SLen Brown 	if (do_nhm_cstates && !do_slm_cstates)
534fc04cc67SLen Brown 		outp += sprintf(outp, "%8.2f", 100.0 * p->pc3/t->tsc);
535144b44b1SLen Brown 	if (do_nhm_cstates && !do_slm_cstates)
536fc04cc67SLen Brown 		outp += sprintf(outp, "%8.2f", 100.0 * p->pc6/t->tsc);
537103a8feaSLen Brown 	if (do_snb_cstates)
538fc04cc67SLen Brown 		outp += sprintf(outp, "%8.2f", 100.0 * p->pc7/t->tsc);
539ca58710fSKristen Carlson Accardi 	if (do_c8_c9_c10) {
540fc04cc67SLen Brown 		outp += sprintf(outp, "%8.2f", 100.0 * p->pc8/t->tsc);
541fc04cc67SLen Brown 		outp += sprintf(outp, "%8.2f", 100.0 * p->pc9/t->tsc);
542fc04cc67SLen Brown 		outp += sprintf(outp, "%8.2f", 100.0 * p->pc10/t->tsc);
543ca58710fSKristen Carlson Accardi 	}
544889facbeSLen Brown 
545889facbeSLen Brown 	/*
546889facbeSLen Brown  	 * If measurement interval exceeds minimum RAPL Joule Counter range,
547889facbeSLen Brown  	 * indicate that results are suspect by printing "**" in fraction place.
548889facbeSLen Brown  	 */
549fc04cc67SLen Brown 	if (interval_float < rapl_joule_counter_range)
550fc04cc67SLen Brown 		fmt8 = "%8.2f";
551fc04cc67SLen Brown 	else
552fc04cc67SLen Brown 		fmt8 = " %6.0f**";
553889facbeSLen Brown 
5545c56be9aSDirk Brandewie 	if (do_rapl && !rapl_joules) {
555889facbeSLen Brown 		if (do_rapl & RAPL_PKG)
556fc04cc67SLen Brown 			outp += sprintf(outp, fmt8, p->energy_pkg * rapl_energy_units / interval_float);
557889facbeSLen Brown 		if (do_rapl & RAPL_CORES)
558fc04cc67SLen Brown 			outp += sprintf(outp, fmt8, p->energy_cores * rapl_energy_units / interval_float);
559889facbeSLen Brown 		if (do_rapl & RAPL_GFX)
560fc04cc67SLen Brown 			outp += sprintf(outp, fmt8, p->energy_gfx * rapl_energy_units / interval_float);
561889facbeSLen Brown 		if (do_rapl & RAPL_DRAM)
562fc04cc67SLen Brown 			outp += sprintf(outp, fmt8, p->energy_dram * rapl_energy_units / interval_float);
563889facbeSLen Brown 		if (do_rapl & RAPL_PKG_PERF_STATUS)
564fc04cc67SLen Brown 			outp += sprintf(outp, fmt8, 100.0 * p->rapl_pkg_perf_status * rapl_time_units / interval_float);
565889facbeSLen Brown 		if (do_rapl & RAPL_DRAM_PERF_STATUS)
566fc04cc67SLen Brown 			outp += sprintf(outp, fmt8, 100.0 * p->rapl_dram_perf_status * rapl_time_units / interval_float);
567d7899447SLen Brown 	} else if (do_rapl && rapl_joules) {
5685c56be9aSDirk Brandewie 		if (do_rapl & RAPL_PKG)
569fc04cc67SLen Brown 			outp += sprintf(outp, fmt8,
5705c56be9aSDirk Brandewie 					p->energy_pkg * rapl_energy_units);
5715c56be9aSDirk Brandewie 		if (do_rapl & RAPL_CORES)
572fc04cc67SLen Brown 			outp += sprintf(outp, fmt8,
5735c56be9aSDirk Brandewie 					p->energy_cores * rapl_energy_units);
5745c56be9aSDirk Brandewie 		if (do_rapl & RAPL_GFX)
575fc04cc67SLen Brown 			outp += sprintf(outp, fmt8,
5765c56be9aSDirk Brandewie 					p->energy_gfx * rapl_energy_units);
5775c56be9aSDirk Brandewie 		if (do_rapl & RAPL_DRAM)
578fc04cc67SLen Brown 			outp += sprintf(outp, fmt8,
5795c56be9aSDirk Brandewie 					p->energy_dram * rapl_energy_units);
5805c56be9aSDirk Brandewie 		if (do_rapl & RAPL_PKG_PERF_STATUS)
581fc04cc67SLen Brown 			outp += sprintf(outp, fmt8, 100.0 * p->rapl_pkg_perf_status * rapl_time_units / interval_float);
5825c56be9aSDirk Brandewie 		if (do_rapl & RAPL_DRAM_PERF_STATUS)
583fc04cc67SLen Brown 			outp += sprintf(outp, fmt8, 100.0 * p->rapl_dram_perf_status * rapl_time_units / interval_float);
584889facbeSLen Brown 
585d7899447SLen Brown 		outp += sprintf(outp, fmt8, interval_float);
5865c56be9aSDirk Brandewie 	}
587c98d5d94SLen Brown done:
588c98d5d94SLen Brown 	outp += sprintf(outp, "\n");
589c98d5d94SLen Brown 
590c98d5d94SLen Brown 	return 0;
591103a8feaSLen Brown }
592103a8feaSLen Brown 
593c98d5d94SLen Brown void flush_stdout()
594103a8feaSLen Brown {
595c98d5d94SLen Brown 	fputs(output_buffer, stdout);
596ddac0d68SLen Brown 	fflush(stdout);
597c98d5d94SLen Brown 	outp = output_buffer;
598c98d5d94SLen Brown }
599c98d5d94SLen Brown void flush_stderr()
600c98d5d94SLen Brown {
601c98d5d94SLen Brown 	fputs(output_buffer, stderr);
602c98d5d94SLen Brown 	outp = output_buffer;
603c98d5d94SLen Brown }
604c98d5d94SLen Brown void format_all_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
605c98d5d94SLen Brown {
606e23da037SLen Brown 	static int printed;
607103a8feaSLen Brown 
608e23da037SLen Brown 	if (!printed || !summary_only)
609103a8feaSLen Brown 		print_header();
610103a8feaSLen Brown 
611c98d5d94SLen Brown 	if (topo.num_cpus > 1)
612c98d5d94SLen Brown 		format_counters(&average.threads, &average.cores,
613c98d5d94SLen Brown 			&average.packages);
614103a8feaSLen Brown 
615e23da037SLen Brown 	printed = 1;
616e23da037SLen Brown 
617e23da037SLen Brown 	if (summary_only)
618e23da037SLen Brown 		return;
619e23da037SLen Brown 
620c98d5d94SLen Brown 	for_all_cpus(format_counters, t, c, p);
621103a8feaSLen Brown }
622103a8feaSLen Brown 
623889facbeSLen Brown #define DELTA_WRAP32(new, old)			\
624889facbeSLen Brown 	if (new > old) {			\
625889facbeSLen Brown 		old = new - old;		\
626889facbeSLen Brown 	} else {				\
627889facbeSLen Brown 		old = 0x100000000 + new - old;	\
628889facbeSLen Brown 	}
629889facbeSLen Brown 
630c98d5d94SLen Brown void
631c98d5d94SLen Brown delta_package(struct pkg_data *new, struct pkg_data *old)
632103a8feaSLen Brown {
633c98d5d94SLen Brown 	old->pc2 = new->pc2 - old->pc2;
634c98d5d94SLen Brown 	old->pc3 = new->pc3 - old->pc3;
635c98d5d94SLen Brown 	old->pc6 = new->pc6 - old->pc6;
636c98d5d94SLen Brown 	old->pc7 = new->pc7 - old->pc7;
637ca58710fSKristen Carlson Accardi 	old->pc8 = new->pc8 - old->pc8;
638ca58710fSKristen Carlson Accardi 	old->pc9 = new->pc9 - old->pc9;
639ca58710fSKristen Carlson Accardi 	old->pc10 = new->pc10 - old->pc10;
640889facbeSLen Brown 	old->pkg_temp_c = new->pkg_temp_c;
641889facbeSLen Brown 
642889facbeSLen Brown 	DELTA_WRAP32(new->energy_pkg, old->energy_pkg);
643889facbeSLen Brown 	DELTA_WRAP32(new->energy_cores, old->energy_cores);
644889facbeSLen Brown 	DELTA_WRAP32(new->energy_gfx, old->energy_gfx);
645889facbeSLen Brown 	DELTA_WRAP32(new->energy_dram, old->energy_dram);
646889facbeSLen Brown 	DELTA_WRAP32(new->rapl_pkg_perf_status, old->rapl_pkg_perf_status);
647889facbeSLen Brown 	DELTA_WRAP32(new->rapl_dram_perf_status, old->rapl_dram_perf_status);
648103a8feaSLen Brown }
649103a8feaSLen Brown 
650c98d5d94SLen Brown void
651c98d5d94SLen Brown delta_core(struct core_data *new, struct core_data *old)
652c98d5d94SLen Brown {
653c98d5d94SLen Brown 	old->c3 = new->c3 - old->c3;
654c98d5d94SLen Brown 	old->c6 = new->c6 - old->c6;
655c98d5d94SLen Brown 	old->c7 = new->c7 - old->c7;
656889facbeSLen Brown 	old->core_temp_c = new->core_temp_c;
657103a8feaSLen Brown }
658c98d5d94SLen Brown 
659c3ae331dSLen Brown /*
660c3ae331dSLen Brown  * old = new - old
661c3ae331dSLen Brown  */
662c98d5d94SLen Brown void
663c98d5d94SLen Brown delta_thread(struct thread_data *new, struct thread_data *old,
664c98d5d94SLen Brown 	struct core_data *core_delta)
665c98d5d94SLen Brown {
666c98d5d94SLen Brown 	old->tsc = new->tsc - old->tsc;
667c98d5d94SLen Brown 
668103a8feaSLen Brown 	/* check for TSC < 1 Mcycles over interval */
669b2c95d90SJosh Triplett 	if (old->tsc < (1000 * 1000))
670b2c95d90SJosh Triplett 		errx(-3, "Insanely slow TSC rate, TSC stops in idle?\n"
671b2c95d90SJosh Triplett 		     "You can disable all c-states by booting with \"idle=poll\"\n"
672b2c95d90SJosh Triplett 		     "or just the deep ones with \"processor.max_cstate=1\"");
673103a8feaSLen Brown 
674c98d5d94SLen Brown 	old->c1 = new->c1 - old->c1;
675c98d5d94SLen Brown 
676*a729617cSLen Brown 	if (has_aperf) {
677c98d5d94SLen Brown 		if ((new->aperf > old->aperf) && (new->mperf > old->mperf)) {
678c98d5d94SLen Brown 			old->aperf = new->aperf - old->aperf;
679c98d5d94SLen Brown 			old->mperf = new->mperf - old->mperf;
680c98d5d94SLen Brown 		} else {
681c98d5d94SLen Brown 
682103a8feaSLen Brown 			if (!aperf_mperf_unstable) {
683103a8feaSLen Brown 				fprintf(stderr, "%s: APERF or MPERF went backwards *\n", progname);
684103a8feaSLen Brown 				fprintf(stderr, "* Frequency results do not cover entire interval *\n");
685103a8feaSLen Brown 				fprintf(stderr, "* fix this by running Linux-2.6.30 or later *\n");
686103a8feaSLen Brown 
687103a8feaSLen Brown 				aperf_mperf_unstable = 1;
688103a8feaSLen Brown 			}
689103a8feaSLen Brown 			/*
690103a8feaSLen Brown 			 * mperf delta is likely a huge "positive" number
691103a8feaSLen Brown 			 * can not use it for calculating c0 time
692103a8feaSLen Brown 			 */
693103a8feaSLen Brown 			skip_c0 = 1;
694103a8feaSLen Brown 			skip_c1 = 1;
695103a8feaSLen Brown 		}
696*a729617cSLen Brown 	}
697103a8feaSLen Brown 
698c98d5d94SLen Brown 
699144b44b1SLen Brown 	if (use_c1_residency_msr) {
700144b44b1SLen Brown 		/*
701144b44b1SLen Brown 		 * Some models have a dedicated C1 residency MSR,
702144b44b1SLen Brown 		 * which should be more accurate than the derivation below.
703144b44b1SLen Brown 		 */
704144b44b1SLen Brown 	} else {
705103a8feaSLen Brown 		/*
706c3ae331dSLen Brown 		 * As counter collection is not atomic,
707c3ae331dSLen Brown 		 * it is possible for mperf's non-halted cycles + idle states
708103a8feaSLen Brown 		 * to exceed TSC's all cycles: show c1 = 0% in that case.
709103a8feaSLen Brown 		 */
710c3ae331dSLen Brown 		if ((old->mperf + core_delta->c3 + core_delta->c6 + core_delta->c7) > old->tsc)
711c98d5d94SLen Brown 			old->c1 = 0;
712c98d5d94SLen Brown 		else {
713c98d5d94SLen Brown 			/* normal case, derive c1 */
714c98d5d94SLen Brown 			old->c1 = old->tsc - old->mperf - core_delta->c3
715c98d5d94SLen Brown 				- core_delta->c6 - core_delta->c7;
716c98d5d94SLen Brown 		}
717144b44b1SLen Brown 	}
718c3ae331dSLen Brown 
719c98d5d94SLen Brown 	if (old->mperf == 0) {
720c3ae331dSLen Brown 		if (verbose > 1) fprintf(stderr, "cpu%d MPERF 0!\n", old->cpu_id);
721c98d5d94SLen Brown 		old->mperf = 1;	/* divide by 0 protection */
722c98d5d94SLen Brown 	}
723103a8feaSLen Brown 
7248e180f3cSLen Brown 	old->extra_delta32 = new->extra_delta32 - old->extra_delta32;
7258e180f3cSLen Brown 	old->extra_delta32 &= 0xFFFFFFFF;
7268e180f3cSLen Brown 
7278e180f3cSLen Brown 	old->extra_delta64 = new->extra_delta64 - old->extra_delta64;
7288e180f3cSLen Brown 
729103a8feaSLen Brown 	/*
7308e180f3cSLen Brown 	 * Extra MSR is just a snapshot, simply copy latest w/o subtracting
731103a8feaSLen Brown 	 */
7322f32edf1SLen Brown 	old->extra_msr32 = new->extra_msr32;
7332f32edf1SLen Brown 	old->extra_msr64 = new->extra_msr64;
7341ed51011SLen Brown 
7351ed51011SLen Brown 	if (do_smi)
7361ed51011SLen Brown 		old->smi_count = new->smi_count - old->smi_count;
737103a8feaSLen Brown }
738c98d5d94SLen Brown 
739c98d5d94SLen Brown int delta_cpu(struct thread_data *t, struct core_data *c,
740c98d5d94SLen Brown 	struct pkg_data *p, struct thread_data *t2,
741c98d5d94SLen Brown 	struct core_data *c2, struct pkg_data *p2)
742c98d5d94SLen Brown {
743c98d5d94SLen Brown 	/* calculate core delta only for 1st thread in core */
744c98d5d94SLen Brown 	if (t->flags & CPU_IS_FIRST_THREAD_IN_CORE)
745c98d5d94SLen Brown 		delta_core(c, c2);
746c98d5d94SLen Brown 
747c98d5d94SLen Brown 	/* always calculate thread delta */
748c98d5d94SLen Brown 	delta_thread(t, t2, c2);	/* c2 is core delta */
749c98d5d94SLen Brown 
750c98d5d94SLen Brown 	/* calculate package delta only for 1st core in package */
751c98d5d94SLen Brown 	if (t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE)
752c98d5d94SLen Brown 		delta_package(p, p2);
753c98d5d94SLen Brown 
754103a8feaSLen Brown 	return 0;
755103a8feaSLen Brown }
756103a8feaSLen Brown 
757c98d5d94SLen Brown void clear_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
758103a8feaSLen Brown {
759c98d5d94SLen Brown 	t->tsc = 0;
760c98d5d94SLen Brown 	t->aperf = 0;
761c98d5d94SLen Brown 	t->mperf = 0;
762c98d5d94SLen Brown 	t->c1 = 0;
763103a8feaSLen Brown 
7641ed51011SLen Brown 	t->smi_count = 0;
7658e180f3cSLen Brown 	t->extra_delta32 = 0;
7668e180f3cSLen Brown 	t->extra_delta64 = 0;
7678e180f3cSLen Brown 
768c98d5d94SLen Brown 	/* tells format_counters to dump all fields from this set */
769c98d5d94SLen Brown 	t->flags = CPU_IS_FIRST_THREAD_IN_CORE | CPU_IS_FIRST_CORE_IN_PACKAGE;
770c98d5d94SLen Brown 
771c98d5d94SLen Brown 	c->c3 = 0;
772c98d5d94SLen Brown 	c->c6 = 0;
773c98d5d94SLen Brown 	c->c7 = 0;
774889facbeSLen Brown 	c->core_temp_c = 0;
775c98d5d94SLen Brown 
776c98d5d94SLen Brown 	p->pc2 = 0;
777c98d5d94SLen Brown 	p->pc3 = 0;
778c98d5d94SLen Brown 	p->pc6 = 0;
779c98d5d94SLen Brown 	p->pc7 = 0;
780ca58710fSKristen Carlson Accardi 	p->pc8 = 0;
781ca58710fSKristen Carlson Accardi 	p->pc9 = 0;
782ca58710fSKristen Carlson Accardi 	p->pc10 = 0;
783889facbeSLen Brown 
784889facbeSLen Brown 	p->energy_pkg = 0;
785889facbeSLen Brown 	p->energy_dram = 0;
786889facbeSLen Brown 	p->energy_cores = 0;
787889facbeSLen Brown 	p->energy_gfx = 0;
788889facbeSLen Brown 	p->rapl_pkg_perf_status = 0;
789889facbeSLen Brown 	p->rapl_dram_perf_status = 0;
790889facbeSLen Brown 	p->pkg_temp_c = 0;
791103a8feaSLen Brown }
792c98d5d94SLen Brown int sum_counters(struct thread_data *t, struct core_data *c,
793c98d5d94SLen Brown 	struct pkg_data *p)
794103a8feaSLen Brown {
795c98d5d94SLen Brown 	average.threads.tsc += t->tsc;
796c98d5d94SLen Brown 	average.threads.aperf += t->aperf;
797c98d5d94SLen Brown 	average.threads.mperf += t->mperf;
798c98d5d94SLen Brown 	average.threads.c1 += t->c1;
79915aaa346SLen Brown 
8008e180f3cSLen Brown 	average.threads.extra_delta32 += t->extra_delta32;
8018e180f3cSLen Brown 	average.threads.extra_delta64 += t->extra_delta64;
8028e180f3cSLen Brown 
803c98d5d94SLen Brown 	/* sum per-core values only for 1st thread in core */
804c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
805c98d5d94SLen Brown 		return 0;
806c98d5d94SLen Brown 
807c98d5d94SLen Brown 	average.cores.c3 += c->c3;
808c98d5d94SLen Brown 	average.cores.c6 += c->c6;
809c98d5d94SLen Brown 	average.cores.c7 += c->c7;
810c98d5d94SLen Brown 
811889facbeSLen Brown 	average.cores.core_temp_c = MAX(average.cores.core_temp_c, c->core_temp_c);
812889facbeSLen Brown 
813c98d5d94SLen Brown 	/* sum per-pkg values only for 1st core in pkg */
814c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
815c98d5d94SLen Brown 		return 0;
816c98d5d94SLen Brown 
817c98d5d94SLen Brown 	average.packages.pc2 += p->pc2;
818c98d5d94SLen Brown 	average.packages.pc3 += p->pc3;
819c98d5d94SLen Brown 	average.packages.pc6 += p->pc6;
820c98d5d94SLen Brown 	average.packages.pc7 += p->pc7;
821ca58710fSKristen Carlson Accardi 	average.packages.pc8 += p->pc8;
822ca58710fSKristen Carlson Accardi 	average.packages.pc9 += p->pc9;
823ca58710fSKristen Carlson Accardi 	average.packages.pc10 += p->pc10;
824c98d5d94SLen Brown 
825889facbeSLen Brown 	average.packages.energy_pkg += p->energy_pkg;
826889facbeSLen Brown 	average.packages.energy_dram += p->energy_dram;
827889facbeSLen Brown 	average.packages.energy_cores += p->energy_cores;
828889facbeSLen Brown 	average.packages.energy_gfx += p->energy_gfx;
829889facbeSLen Brown 
830889facbeSLen Brown 	average.packages.pkg_temp_c = MAX(average.packages.pkg_temp_c, p->pkg_temp_c);
831889facbeSLen Brown 
832889facbeSLen Brown 	average.packages.rapl_pkg_perf_status += p->rapl_pkg_perf_status;
833889facbeSLen Brown 	average.packages.rapl_dram_perf_status += p->rapl_dram_perf_status;
834c98d5d94SLen Brown 	return 0;
835c98d5d94SLen Brown }
836c98d5d94SLen Brown /*
837c98d5d94SLen Brown  * sum the counters for all cpus in the system
838c98d5d94SLen Brown  * compute the weighted average
839c98d5d94SLen Brown  */
840c98d5d94SLen Brown void compute_average(struct thread_data *t, struct core_data *c,
841c98d5d94SLen Brown 	struct pkg_data *p)
842c98d5d94SLen Brown {
843c98d5d94SLen Brown 	clear_counters(&average.threads, &average.cores, &average.packages);
844c98d5d94SLen Brown 
845c98d5d94SLen Brown 	for_all_cpus(sum_counters, t, c, p);
846c98d5d94SLen Brown 
847c98d5d94SLen Brown 	average.threads.tsc /= topo.num_cpus;
848c98d5d94SLen Brown 	average.threads.aperf /= topo.num_cpus;
849c98d5d94SLen Brown 	average.threads.mperf /= topo.num_cpus;
850c98d5d94SLen Brown 	average.threads.c1 /= topo.num_cpus;
851c98d5d94SLen Brown 
8528e180f3cSLen Brown 	average.threads.extra_delta32 /= topo.num_cpus;
8538e180f3cSLen Brown 	average.threads.extra_delta32 &= 0xFFFFFFFF;
8548e180f3cSLen Brown 
8558e180f3cSLen Brown 	average.threads.extra_delta64 /= topo.num_cpus;
8568e180f3cSLen Brown 
857c98d5d94SLen Brown 	average.cores.c3 /= topo.num_cores;
858c98d5d94SLen Brown 	average.cores.c6 /= topo.num_cores;
859c98d5d94SLen Brown 	average.cores.c7 /= topo.num_cores;
860c98d5d94SLen Brown 
861c98d5d94SLen Brown 	average.packages.pc2 /= topo.num_packages;
862c98d5d94SLen Brown 	average.packages.pc3 /= topo.num_packages;
863c98d5d94SLen Brown 	average.packages.pc6 /= topo.num_packages;
864c98d5d94SLen Brown 	average.packages.pc7 /= topo.num_packages;
865ca58710fSKristen Carlson Accardi 
866ca58710fSKristen Carlson Accardi 	average.packages.pc8 /= topo.num_packages;
867ca58710fSKristen Carlson Accardi 	average.packages.pc9 /= topo.num_packages;
868ca58710fSKristen Carlson Accardi 	average.packages.pc10 /= topo.num_packages;
869c98d5d94SLen Brown }
870c98d5d94SLen Brown 
871c98d5d94SLen Brown static unsigned long long rdtsc(void)
872c98d5d94SLen Brown {
873c98d5d94SLen Brown 	unsigned int low, high;
874c98d5d94SLen Brown 
875c98d5d94SLen Brown 	asm volatile("rdtsc" : "=a" (low), "=d" (high));
876c98d5d94SLen Brown 
877c98d5d94SLen Brown 	return low | ((unsigned long long)high) << 32;
878c98d5d94SLen Brown }
879c98d5d94SLen Brown 
880c98d5d94SLen Brown 
881c98d5d94SLen Brown /*
882c98d5d94SLen Brown  * get_counters(...)
883c98d5d94SLen Brown  * migrate to cpu
884c98d5d94SLen Brown  * acquire and record local counters for that cpu
885c98d5d94SLen Brown  */
886c98d5d94SLen Brown int get_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
887c98d5d94SLen Brown {
888c98d5d94SLen Brown 	int cpu = t->cpu_id;
889889facbeSLen Brown 	unsigned long long msr;
890c98d5d94SLen Brown 
891e52966c0SLen Brown 	if (cpu_migrate(cpu)) {
892e52966c0SLen Brown 		fprintf(stderr, "Could not migrate to CPU %d\n", cpu);
89315aaa346SLen Brown 		return -1;
894e52966c0SLen Brown 	}
89515aaa346SLen Brown 
896c98d5d94SLen Brown 	t->tsc = rdtsc();	/* we are running on local CPU of interest */
89715aaa346SLen Brown 
89815aaa346SLen Brown 	if (has_aperf) {
8999c63a650SLen Brown 		if (get_msr(cpu, MSR_IA32_APERF, &t->aperf))
900c98d5d94SLen Brown 			return -3;
9019c63a650SLen Brown 		if (get_msr(cpu, MSR_IA32_MPERF, &t->mperf))
902c98d5d94SLen Brown 			return -4;
90388c3281fSLen Brown 	}
90488c3281fSLen Brown 
9051ed51011SLen Brown 	if (do_smi) {
9061ed51011SLen Brown 		if (get_msr(cpu, MSR_SMI_COUNT, &msr))
9071ed51011SLen Brown 			return -5;
9081ed51011SLen Brown 		t->smi_count = msr & 0xFFFFFFFF;
9091ed51011SLen Brown 	}
9108e180f3cSLen Brown 	if (extra_delta_offset32) {
911889facbeSLen Brown 		if (get_msr(cpu, extra_delta_offset32, &msr))
9122f32edf1SLen Brown 			return -5;
913889facbeSLen Brown 		t->extra_delta32 = msr & 0xFFFFFFFF;
9148e180f3cSLen Brown 	}
9158e180f3cSLen Brown 
9168e180f3cSLen Brown 	if (extra_delta_offset64)
9178e180f3cSLen Brown 		if (get_msr(cpu, extra_delta_offset64, &t->extra_delta64))
9188e180f3cSLen Brown 			return -5;
9198e180f3cSLen Brown 
9208e180f3cSLen Brown 	if (extra_msr_offset32) {
921889facbeSLen Brown 		if (get_msr(cpu, extra_msr_offset32, &msr))
9228e180f3cSLen Brown 			return -5;
923889facbeSLen Brown 		t->extra_msr32 = msr & 0xFFFFFFFF;
9248e180f3cSLen Brown 	}
9252f32edf1SLen Brown 
9262f32edf1SLen Brown 	if (extra_msr_offset64)
9272f32edf1SLen Brown 		if (get_msr(cpu, extra_msr_offset64, &t->extra_msr64))
928c98d5d94SLen Brown 			return -5;
929c98d5d94SLen Brown 
930144b44b1SLen Brown 	if (use_c1_residency_msr) {
931144b44b1SLen Brown 		if (get_msr(cpu, MSR_CORE_C1_RES, &t->c1))
932144b44b1SLen Brown 			return -6;
933144b44b1SLen Brown 	}
934144b44b1SLen Brown 
935c98d5d94SLen Brown 	/* collect core counters only for 1st thread in core */
936c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
937c98d5d94SLen Brown 		return 0;
938c98d5d94SLen Brown 
939144b44b1SLen Brown 	if (do_nhm_cstates && !do_slm_cstates) {
940c98d5d94SLen Brown 		if (get_msr(cpu, MSR_CORE_C3_RESIDENCY, &c->c3))
941c98d5d94SLen Brown 			return -6;
942144b44b1SLen Brown 	}
943144b44b1SLen Brown 
944144b44b1SLen Brown 	if (do_nhm_cstates) {
945c98d5d94SLen Brown 		if (get_msr(cpu, MSR_CORE_C6_RESIDENCY, &c->c6))
946c98d5d94SLen Brown 			return -7;
947103a8feaSLen Brown 	}
94815aaa346SLen Brown 
94915aaa346SLen Brown 	if (do_snb_cstates)
950c98d5d94SLen Brown 		if (get_msr(cpu, MSR_CORE_C7_RESIDENCY, &c->c7))
951c98d5d94SLen Brown 			return -8;
952c98d5d94SLen Brown 
953889facbeSLen Brown 	if (do_dts) {
954889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_THERM_STATUS, &msr))
955889facbeSLen Brown 			return -9;
956889facbeSLen Brown 		c->core_temp_c = tcc_activation_temp - ((msr >> 16) & 0x7F);
957889facbeSLen Brown 	}
958889facbeSLen Brown 
959889facbeSLen Brown 
960c98d5d94SLen Brown 	/* collect package counters only for 1st core in package */
961c98d5d94SLen Brown 	if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
962c98d5d94SLen Brown 		return 0;
96315aaa346SLen Brown 
964144b44b1SLen Brown 	if (do_nhm_cstates && !do_slm_cstates) {
965c98d5d94SLen Brown 		if (get_msr(cpu, MSR_PKG_C3_RESIDENCY, &p->pc3))
966c98d5d94SLen Brown 			return -9;
967c98d5d94SLen Brown 		if (get_msr(cpu, MSR_PKG_C6_RESIDENCY, &p->pc6))
968c98d5d94SLen Brown 			return -10;
96915aaa346SLen Brown 	}
97015aaa346SLen Brown 	if (do_snb_cstates) {
971c98d5d94SLen Brown 		if (get_msr(cpu, MSR_PKG_C2_RESIDENCY, &p->pc2))
972c98d5d94SLen Brown 			return -11;
973c98d5d94SLen Brown 		if (get_msr(cpu, MSR_PKG_C7_RESIDENCY, &p->pc7))
974c98d5d94SLen Brown 			return -12;
97515aaa346SLen Brown 	}
976ca58710fSKristen Carlson Accardi 	if (do_c8_c9_c10) {
977ca58710fSKristen Carlson Accardi 		if (get_msr(cpu, MSR_PKG_C8_RESIDENCY, &p->pc8))
978ca58710fSKristen Carlson Accardi 			return -13;
979ca58710fSKristen Carlson Accardi 		if (get_msr(cpu, MSR_PKG_C9_RESIDENCY, &p->pc9))
980ca58710fSKristen Carlson Accardi 			return -13;
981ca58710fSKristen Carlson Accardi 		if (get_msr(cpu, MSR_PKG_C10_RESIDENCY, &p->pc10))
982ca58710fSKristen Carlson Accardi 			return -13;
983ca58710fSKristen Carlson Accardi 	}
984889facbeSLen Brown 	if (do_rapl & RAPL_PKG) {
985889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_ENERGY_STATUS, &msr))
986889facbeSLen Brown 			return -13;
987889facbeSLen Brown 		p->energy_pkg = msr & 0xFFFFFFFF;
988889facbeSLen Brown 	}
989889facbeSLen Brown 	if (do_rapl & RAPL_CORES) {
990889facbeSLen Brown 		if (get_msr(cpu, MSR_PP0_ENERGY_STATUS, &msr))
991889facbeSLen Brown 			return -14;
992889facbeSLen Brown 		p->energy_cores = msr & 0xFFFFFFFF;
993889facbeSLen Brown 	}
994889facbeSLen Brown 	if (do_rapl & RAPL_DRAM) {
995889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_ENERGY_STATUS, &msr))
996889facbeSLen Brown 			return -15;
997889facbeSLen Brown 		p->energy_dram = msr & 0xFFFFFFFF;
998889facbeSLen Brown 	}
999889facbeSLen Brown 	if (do_rapl & RAPL_GFX) {
1000889facbeSLen Brown 		if (get_msr(cpu, MSR_PP1_ENERGY_STATUS, &msr))
1001889facbeSLen Brown 			return -16;
1002889facbeSLen Brown 		p->energy_gfx = msr & 0xFFFFFFFF;
1003889facbeSLen Brown 	}
1004889facbeSLen Brown 	if (do_rapl & RAPL_PKG_PERF_STATUS) {
1005889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_PERF_STATUS, &msr))
1006889facbeSLen Brown 			return -16;
1007889facbeSLen Brown 		p->rapl_pkg_perf_status = msr & 0xFFFFFFFF;
1008889facbeSLen Brown 	}
1009889facbeSLen Brown 	if (do_rapl & RAPL_DRAM_PERF_STATUS) {
1010889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_PERF_STATUS, &msr))
1011889facbeSLen Brown 			return -16;
1012889facbeSLen Brown 		p->rapl_dram_perf_status = msr & 0xFFFFFFFF;
1013889facbeSLen Brown 	}
1014889facbeSLen Brown 	if (do_ptm) {
1015889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_STATUS, &msr))
1016889facbeSLen Brown 			return -17;
1017889facbeSLen Brown 		p->pkg_temp_c = tcc_activation_temp - ((msr >> 16) & 0x7F);
1018889facbeSLen Brown 	}
101915aaa346SLen Brown 	return 0;
1020103a8feaSLen Brown }
1021103a8feaSLen Brown 
1022c98d5d94SLen Brown void print_verbose_header(void)
1023103a8feaSLen Brown {
1024103a8feaSLen Brown 	unsigned long long msr;
1025103a8feaSLen Brown 	unsigned int ratio;
1026103a8feaSLen Brown 
1027d7899447SLen Brown 	if (!do_nhm_platform_info)
1028103a8feaSLen Brown 		return;
1029103a8feaSLen Brown 
10309c63a650SLen Brown 	get_msr(0, MSR_NHM_PLATFORM_INFO, &msr);
1031103a8feaSLen Brown 
1032889facbeSLen Brown 	fprintf(stderr, "cpu0: MSR_NHM_PLATFORM_INFO: 0x%08llx\n", msr);
10336574a5d5SLen Brown 
1034103a8feaSLen Brown 	ratio = (msr >> 40) & 0xFF;
1035103a8feaSLen Brown 	fprintf(stderr, "%d * %.0f = %.0f MHz max efficiency\n",
1036103a8feaSLen Brown 		ratio, bclk, ratio * bclk);
1037103a8feaSLen Brown 
1038103a8feaSLen Brown 	ratio = (msr >> 8) & 0xFF;
1039103a8feaSLen Brown 	fprintf(stderr, "%d * %.0f = %.0f MHz TSC frequency\n",
1040103a8feaSLen Brown 		ratio, bclk, ratio * bclk);
1041103a8feaSLen Brown 
104267920418SLen Brown 	get_msr(0, MSR_IA32_POWER_CTL, &msr);
1043144b44b1SLen Brown 	fprintf(stderr, "cpu0: MSR_IA32_POWER_CTL: 0x%08llx (C1E auto-promotion: %sabled)\n",
104467920418SLen Brown 		msr, msr & 0x2 ? "EN" : "DIS");
104567920418SLen Brown 
10466574a5d5SLen Brown 	if (!do_ivt_turbo_ratio_limit)
10476574a5d5SLen Brown 		goto print_nhm_turbo_ratio_limits;
10486574a5d5SLen Brown 
10496574a5d5SLen Brown 	get_msr(0, MSR_IVT_TURBO_RATIO_LIMIT, &msr);
10506574a5d5SLen Brown 
1051889facbeSLen Brown 	fprintf(stderr, "cpu0: MSR_IVT_TURBO_RATIO_LIMIT: 0x%08llx\n", msr);
10526574a5d5SLen Brown 
10536574a5d5SLen Brown 	ratio = (msr >> 56) & 0xFF;
10546574a5d5SLen Brown 	if (ratio)
10556574a5d5SLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 16 active cores\n",
10566574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
10576574a5d5SLen Brown 
10586574a5d5SLen Brown 	ratio = (msr >> 48) & 0xFF;
10596574a5d5SLen Brown 	if (ratio)
10606574a5d5SLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 15 active cores\n",
10616574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
10626574a5d5SLen Brown 
10636574a5d5SLen Brown 	ratio = (msr >> 40) & 0xFF;
10646574a5d5SLen Brown 	if (ratio)
10656574a5d5SLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 14 active cores\n",
10666574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
10676574a5d5SLen Brown 
10686574a5d5SLen Brown 	ratio = (msr >> 32) & 0xFF;
10696574a5d5SLen Brown 	if (ratio)
10706574a5d5SLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 13 active cores\n",
10716574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
10726574a5d5SLen Brown 
10736574a5d5SLen Brown 	ratio = (msr >> 24) & 0xFF;
10746574a5d5SLen Brown 	if (ratio)
10756574a5d5SLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 12 active cores\n",
10766574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
10776574a5d5SLen Brown 
10786574a5d5SLen Brown 	ratio = (msr >> 16) & 0xFF;
10796574a5d5SLen Brown 	if (ratio)
10806574a5d5SLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 11 active cores\n",
10816574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
10826574a5d5SLen Brown 
10836574a5d5SLen Brown 	ratio = (msr >> 8) & 0xFF;
10846574a5d5SLen Brown 	if (ratio)
10856574a5d5SLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 10 active cores\n",
10866574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
10876574a5d5SLen Brown 
10886574a5d5SLen Brown 	ratio = (msr >> 0) & 0xFF;
10896574a5d5SLen Brown 	if (ratio)
10906574a5d5SLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 9 active cores\n",
10916574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
10926574a5d5SLen Brown 
10936574a5d5SLen Brown print_nhm_turbo_ratio_limits:
1094889facbeSLen Brown 	get_msr(0, MSR_NHM_SNB_PKG_CST_CFG_CTL, &msr);
1095889facbeSLen Brown 
1096889facbeSLen Brown #define SNB_C1_AUTO_UNDEMOTE              (1UL << 27)
1097889facbeSLen Brown #define SNB_C3_AUTO_UNDEMOTE              (1UL << 28)
1098889facbeSLen Brown 
1099889facbeSLen Brown 	fprintf(stderr, "cpu0: MSR_NHM_SNB_PKG_CST_CFG_CTL: 0x%08llx", msr);
1100889facbeSLen Brown 
1101889facbeSLen Brown 	fprintf(stderr, " (%s%s%s%s%slocked: pkg-cstate-limit=%d: ",
1102889facbeSLen Brown 		(msr & SNB_C3_AUTO_UNDEMOTE) ? "UNdemote-C3, " : "",
1103889facbeSLen Brown 		(msr & SNB_C1_AUTO_UNDEMOTE) ? "UNdemote-C1, " : "",
1104889facbeSLen Brown 		(msr & NHM_C3_AUTO_DEMOTE) ? "demote-C3, " : "",
1105889facbeSLen Brown 		(msr & NHM_C1_AUTO_DEMOTE) ? "demote-C1, " : "",
1106889facbeSLen Brown 		(msr & (1 << 15)) ? "" : "UN",
1107889facbeSLen Brown 		(unsigned int)msr & 7);
1108889facbeSLen Brown 
1109889facbeSLen Brown 
1110889facbeSLen Brown 	switch(msr & 0x7) {
1111889facbeSLen Brown 	case 0:
1112144b44b1SLen Brown 		fprintf(stderr, do_slm_cstates ? "no pkg states" : "pc0");
1113889facbeSLen Brown 		break;
1114889facbeSLen Brown 	case 1:
1115144b44b1SLen Brown 		fprintf(stderr, do_slm_cstates ? "no pkg states" : do_snb_cstates ? "pc2" : "pc0");
1116889facbeSLen Brown 		break;
1117889facbeSLen Brown 	case 2:
1118144b44b1SLen Brown 		fprintf(stderr, do_slm_cstates ? "invalid" : do_snb_cstates ? "pc6-noret" : "pc3");
1119889facbeSLen Brown 		break;
1120889facbeSLen Brown 	case 3:
1121144b44b1SLen Brown 		fprintf(stderr, do_slm_cstates ? "invalid" : "pc6");
1122889facbeSLen Brown 		break;
1123889facbeSLen Brown 	case 4:
1124144b44b1SLen Brown 		fprintf(stderr, do_slm_cstates ? "pc4" : "pc7");
1125889facbeSLen Brown 		break;
1126889facbeSLen Brown 	case 5:
1127144b44b1SLen Brown 		fprintf(stderr, do_slm_cstates ? "invalid" : do_snb_cstates ? "pc7s" : "invalid");
1128144b44b1SLen Brown 		break;
1129144b44b1SLen Brown 	case 6:
1130144b44b1SLen Brown 		fprintf(stderr, do_slm_cstates ? "pc6" : "invalid");
1131889facbeSLen Brown 		break;
1132889facbeSLen Brown 	case 7:
1133144b44b1SLen Brown 		fprintf(stderr, do_slm_cstates ? "pc7" : "unlimited");
1134889facbeSLen Brown 		break;
1135889facbeSLen Brown 	default:
1136889facbeSLen Brown 		fprintf(stderr, "invalid");
1137889facbeSLen Brown 	}
1138889facbeSLen Brown 	fprintf(stderr, ")\n");
1139103a8feaSLen Brown 
1140d7899447SLen Brown 	if (!do_nhm_turbo_ratio_limit)
1141103a8feaSLen Brown 		return;
1142103a8feaSLen Brown 
11439c63a650SLen Brown 	get_msr(0, MSR_NHM_TURBO_RATIO_LIMIT, &msr);
1144103a8feaSLen Brown 
1145889facbeSLen Brown 	fprintf(stderr, "cpu0: MSR_NHM_TURBO_RATIO_LIMIT: 0x%08llx\n", msr);
11466574a5d5SLen Brown 
11476574a5d5SLen Brown 	ratio = (msr >> 56) & 0xFF;
11486574a5d5SLen Brown 	if (ratio)
11496574a5d5SLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 8 active cores\n",
11506574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
11516574a5d5SLen Brown 
11526574a5d5SLen Brown 	ratio = (msr >> 48) & 0xFF;
11536574a5d5SLen Brown 	if (ratio)
11546574a5d5SLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 7 active cores\n",
11556574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
11566574a5d5SLen Brown 
11576574a5d5SLen Brown 	ratio = (msr >> 40) & 0xFF;
11586574a5d5SLen Brown 	if (ratio)
11596574a5d5SLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 6 active cores\n",
11606574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
11616574a5d5SLen Brown 
11626574a5d5SLen Brown 	ratio = (msr >> 32) & 0xFF;
11636574a5d5SLen Brown 	if (ratio)
11646574a5d5SLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 5 active cores\n",
11656574a5d5SLen Brown 			ratio, bclk, ratio * bclk);
11666574a5d5SLen Brown 
1167103a8feaSLen Brown 	ratio = (msr >> 24) & 0xFF;
1168103a8feaSLen Brown 	if (ratio)
1169103a8feaSLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 4 active cores\n",
1170103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1171103a8feaSLen Brown 
1172103a8feaSLen Brown 	ratio = (msr >> 16) & 0xFF;
1173103a8feaSLen Brown 	if (ratio)
1174103a8feaSLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 3 active cores\n",
1175103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1176103a8feaSLen Brown 
1177103a8feaSLen Brown 	ratio = (msr >> 8) & 0xFF;
1178103a8feaSLen Brown 	if (ratio)
1179103a8feaSLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 2 active cores\n",
1180103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
1181103a8feaSLen Brown 
1182103a8feaSLen Brown 	ratio = (msr >> 0) & 0xFF;
1183103a8feaSLen Brown 	if (ratio)
1184103a8feaSLen Brown 		fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 1 active cores\n",
1185103a8feaSLen Brown 			ratio, bclk, ratio * bclk);
11863a9a941dSLen Brown 
1187103a8feaSLen Brown }
1188103a8feaSLen Brown 
1189c98d5d94SLen Brown void free_all_buffers(void)
1190103a8feaSLen Brown {
1191c98d5d94SLen Brown 	CPU_FREE(cpu_present_set);
1192c98d5d94SLen Brown 	cpu_present_set = NULL;
1193c98d5d94SLen Brown 	cpu_present_set = 0;
1194103a8feaSLen Brown 
1195c98d5d94SLen Brown 	CPU_FREE(cpu_affinity_set);
1196c98d5d94SLen Brown 	cpu_affinity_set = NULL;
1197c98d5d94SLen Brown 	cpu_affinity_setsize = 0;
1198103a8feaSLen Brown 
1199c98d5d94SLen Brown 	free(thread_even);
1200c98d5d94SLen Brown 	free(core_even);
1201c98d5d94SLen Brown 	free(package_even);
1202103a8feaSLen Brown 
1203c98d5d94SLen Brown 	thread_even = NULL;
1204c98d5d94SLen Brown 	core_even = NULL;
1205c98d5d94SLen Brown 	package_even = NULL;
1206103a8feaSLen Brown 
1207c98d5d94SLen Brown 	free(thread_odd);
1208c98d5d94SLen Brown 	free(core_odd);
1209c98d5d94SLen Brown 	free(package_odd);
1210103a8feaSLen Brown 
1211c98d5d94SLen Brown 	thread_odd = NULL;
1212c98d5d94SLen Brown 	core_odd = NULL;
1213c98d5d94SLen Brown 	package_odd = NULL;
1214103a8feaSLen Brown 
1215c98d5d94SLen Brown 	free(output_buffer);
1216c98d5d94SLen Brown 	output_buffer = NULL;
1217c98d5d94SLen Brown 	outp = NULL;
1218103a8feaSLen Brown }
1219103a8feaSLen Brown 
1220103a8feaSLen Brown /*
122157a42a34SJosh Triplett  * Open a file, and exit on failure
122257a42a34SJosh Triplett  */
122357a42a34SJosh Triplett FILE *fopen_or_die(const char *path, const char *mode)
122457a42a34SJosh Triplett {
122557a42a34SJosh Triplett 	FILE *filep = fopen(path, "r");
1226b2c95d90SJosh Triplett 	if (!filep)
1227b2c95d90SJosh Triplett 		err(1, "%s: open failed", path);
122857a42a34SJosh Triplett 	return filep;
122957a42a34SJosh Triplett }
123057a42a34SJosh Triplett 
123157a42a34SJosh Triplett /*
123295aebc44SJosh Triplett  * Parse a file containing a single int.
123395aebc44SJosh Triplett  */
123495aebc44SJosh Triplett int parse_int_file(const char *fmt, ...)
123595aebc44SJosh Triplett {
123695aebc44SJosh Triplett 	va_list args;
123795aebc44SJosh Triplett 	char path[PATH_MAX];
123895aebc44SJosh Triplett 	FILE *filep;
123995aebc44SJosh Triplett 	int value;
124095aebc44SJosh Triplett 
124195aebc44SJosh Triplett 	va_start(args, fmt);
124295aebc44SJosh Triplett 	vsnprintf(path, sizeof(path), fmt, args);
124395aebc44SJosh Triplett 	va_end(args);
124457a42a34SJosh Triplett 	filep = fopen_or_die(path, "r");
1245b2c95d90SJosh Triplett 	if (fscanf(filep, "%d", &value) != 1)
1246b2c95d90SJosh Triplett 		err(1, "%s: failed to parse number from file", path);
124795aebc44SJosh Triplett 	fclose(filep);
124895aebc44SJosh Triplett 	return value;
124995aebc44SJosh Triplett }
125095aebc44SJosh Triplett 
125195aebc44SJosh Triplett /*
1252c98d5d94SLen Brown  * cpu_is_first_sibling_in_core(cpu)
1253c98d5d94SLen Brown  * return 1 if given CPU is 1st HT sibling in the core
1254103a8feaSLen Brown  */
1255c98d5d94SLen Brown int cpu_is_first_sibling_in_core(int cpu)
1256103a8feaSLen Brown {
125795aebc44SJosh Triplett 	return cpu == parse_int_file("/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", cpu);
1258c98d5d94SLen Brown }
1259103a8feaSLen Brown 
1260c98d5d94SLen Brown /*
1261c98d5d94SLen Brown  * cpu_is_first_core_in_package(cpu)
1262c98d5d94SLen Brown  * return 1 if given CPU is 1st core in package
1263c98d5d94SLen Brown  */
1264c98d5d94SLen Brown int cpu_is_first_core_in_package(int cpu)
1265c98d5d94SLen Brown {
126695aebc44SJosh Triplett 	return cpu == parse_int_file("/sys/devices/system/cpu/cpu%d/topology/core_siblings_list", cpu);
1267103a8feaSLen Brown }
1268103a8feaSLen Brown 
1269103a8feaSLen Brown int get_physical_package_id(int cpu)
1270103a8feaSLen Brown {
127195aebc44SJosh Triplett 	return parse_int_file("/sys/devices/system/cpu/cpu%d/topology/physical_package_id", cpu);
1272103a8feaSLen Brown }
1273103a8feaSLen Brown 
1274103a8feaSLen Brown int get_core_id(int cpu)
1275103a8feaSLen Brown {
127695aebc44SJosh Triplett 	return parse_int_file("/sys/devices/system/cpu/cpu%d/topology/core_id", cpu);
1277103a8feaSLen Brown }
1278103a8feaSLen Brown 
1279c98d5d94SLen Brown int get_num_ht_siblings(int cpu)
1280c98d5d94SLen Brown {
1281c98d5d94SLen Brown 	char path[80];
1282c98d5d94SLen Brown 	FILE *filep;
1283c98d5d94SLen Brown 	int sib1, sib2;
1284c98d5d94SLen Brown 	int matches;
1285c98d5d94SLen Brown 	char character;
1286c98d5d94SLen Brown 
1287c98d5d94SLen Brown 	sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", cpu);
128857a42a34SJosh Triplett 	filep = fopen_or_die(path, "r");
1289103a8feaSLen Brown 	/*
1290c98d5d94SLen Brown 	 * file format:
1291c98d5d94SLen Brown 	 * if a pair of number with a character between: 2 siblings (eg. 1-2, or 1,4)
1292c98d5d94SLen Brown 	 * otherwinse 1 sibling (self).
1293c98d5d94SLen Brown 	 */
1294c98d5d94SLen Brown 	matches = fscanf(filep, "%d%c%d\n", &sib1, &character, &sib2);
1295c98d5d94SLen Brown 
1296c98d5d94SLen Brown 	fclose(filep);
1297c98d5d94SLen Brown 
1298c98d5d94SLen Brown 	if (matches == 3)
1299c98d5d94SLen Brown 		return 2;
1300c98d5d94SLen Brown 	else
1301c98d5d94SLen Brown 		return 1;
1302c98d5d94SLen Brown }
1303c98d5d94SLen Brown 
1304c98d5d94SLen Brown /*
1305c98d5d94SLen Brown  * run func(thread, core, package) in topology order
1306c98d5d94SLen Brown  * skip non-present cpus
1307103a8feaSLen Brown  */
1308103a8feaSLen Brown 
1309c98d5d94SLen Brown int for_all_cpus_2(int (func)(struct thread_data *, struct core_data *,
1310c98d5d94SLen Brown 	struct pkg_data *, struct thread_data *, struct core_data *,
1311c98d5d94SLen Brown 	struct pkg_data *), struct thread_data *thread_base,
1312c98d5d94SLen Brown 	struct core_data *core_base, struct pkg_data *pkg_base,
1313c98d5d94SLen Brown 	struct thread_data *thread_base2, struct core_data *core_base2,
1314c98d5d94SLen Brown 	struct pkg_data *pkg_base2)
1315c98d5d94SLen Brown {
1316c98d5d94SLen Brown 	int retval, pkg_no, core_no, thread_no;
1317c98d5d94SLen Brown 
1318c98d5d94SLen Brown 	for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
1319c98d5d94SLen Brown 		for (core_no = 0; core_no < topo.num_cores_per_pkg; ++core_no) {
1320c98d5d94SLen Brown 			for (thread_no = 0; thread_no <
1321c98d5d94SLen Brown 				topo.num_threads_per_core; ++thread_no) {
1322c98d5d94SLen Brown 				struct thread_data *t, *t2;
1323c98d5d94SLen Brown 				struct core_data *c, *c2;
1324c98d5d94SLen Brown 				struct pkg_data *p, *p2;
1325c98d5d94SLen Brown 
1326c98d5d94SLen Brown 				t = GET_THREAD(thread_base, thread_no, core_no, pkg_no);
1327c98d5d94SLen Brown 
1328c98d5d94SLen Brown 				if (cpu_is_not_present(t->cpu_id))
1329c98d5d94SLen Brown 					continue;
1330c98d5d94SLen Brown 
1331c98d5d94SLen Brown 				t2 = GET_THREAD(thread_base2, thread_no, core_no, pkg_no);
1332c98d5d94SLen Brown 
1333c98d5d94SLen Brown 				c = GET_CORE(core_base, core_no, pkg_no);
1334c98d5d94SLen Brown 				c2 = GET_CORE(core_base2, core_no, pkg_no);
1335c98d5d94SLen Brown 
1336c98d5d94SLen Brown 				p = GET_PKG(pkg_base, pkg_no);
1337c98d5d94SLen Brown 				p2 = GET_PKG(pkg_base2, pkg_no);
1338c98d5d94SLen Brown 
1339c98d5d94SLen Brown 				retval = func(t, c, p, t2, c2, p2);
1340c98d5d94SLen Brown 				if (retval)
1341c98d5d94SLen Brown 					return retval;
1342c98d5d94SLen Brown 			}
1343c98d5d94SLen Brown 		}
1344c98d5d94SLen Brown 	}
1345c98d5d94SLen Brown 	return 0;
1346c98d5d94SLen Brown }
1347c98d5d94SLen Brown 
1348c98d5d94SLen Brown /*
1349c98d5d94SLen Brown  * run func(cpu) on every cpu in /proc/stat
1350c98d5d94SLen Brown  * return max_cpu number
1351c98d5d94SLen Brown  */
1352c98d5d94SLen Brown int for_all_proc_cpus(int (func)(int))
1353103a8feaSLen Brown {
1354103a8feaSLen Brown 	FILE *fp;
1355c98d5d94SLen Brown 	int cpu_num;
1356103a8feaSLen Brown 	int retval;
1357103a8feaSLen Brown 
135857a42a34SJosh Triplett 	fp = fopen_or_die(proc_stat, "r");
1359103a8feaSLen Brown 
1360103a8feaSLen Brown 	retval = fscanf(fp, "cpu %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n");
1361b2c95d90SJosh Triplett 	if (retval != 0)
1362b2c95d90SJosh Triplett 		err(1, "%s: failed to parse format", proc_stat);
1363103a8feaSLen Brown 
1364c98d5d94SLen Brown 	while (1) {
1365c98d5d94SLen Brown 		retval = fscanf(fp, "cpu%u %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n", &cpu_num);
1366103a8feaSLen Brown 		if (retval != 1)
1367103a8feaSLen Brown 			break;
1368103a8feaSLen Brown 
1369c98d5d94SLen Brown 		retval = func(cpu_num);
1370c98d5d94SLen Brown 		if (retval) {
1371c98d5d94SLen Brown 			fclose(fp);
1372c98d5d94SLen Brown 			return(retval);
1373c98d5d94SLen Brown 		}
1374103a8feaSLen Brown 	}
1375103a8feaSLen Brown 	fclose(fp);
1376c98d5d94SLen Brown 	return 0;
1377103a8feaSLen Brown }
1378103a8feaSLen Brown 
1379103a8feaSLen Brown void re_initialize(void)
1380103a8feaSLen Brown {
1381c98d5d94SLen Brown 	free_all_buffers();
1382c98d5d94SLen Brown 	setup_all_buffers();
1383c98d5d94SLen Brown 	printf("turbostat: re-initialized with num_cpus %d\n", topo.num_cpus);
1384103a8feaSLen Brown }
1385103a8feaSLen Brown 
1386c98d5d94SLen Brown 
1387103a8feaSLen Brown /*
1388c98d5d94SLen Brown  * count_cpus()
1389c98d5d94SLen Brown  * remember the last one seen, it will be the max
1390103a8feaSLen Brown  */
1391c98d5d94SLen Brown int count_cpus(int cpu)
1392103a8feaSLen Brown {
1393c98d5d94SLen Brown 	if (topo.max_cpu_num < cpu)
1394c98d5d94SLen Brown 		topo.max_cpu_num = cpu;
1395103a8feaSLen Brown 
1396c98d5d94SLen Brown 	topo.num_cpus += 1;
1397c98d5d94SLen Brown 	return 0;
1398103a8feaSLen Brown }
1399c98d5d94SLen Brown int mark_cpu_present(int cpu)
1400c98d5d94SLen Brown {
1401c98d5d94SLen Brown 	CPU_SET_S(cpu, cpu_present_setsize, cpu_present_set);
140215aaa346SLen Brown 	return 0;
1403103a8feaSLen Brown }
1404103a8feaSLen Brown 
1405103a8feaSLen Brown void turbostat_loop()
1406103a8feaSLen Brown {
1407c98d5d94SLen Brown 	int retval;
1408e52966c0SLen Brown 	int restarted = 0;
1409c98d5d94SLen Brown 
1410103a8feaSLen Brown restart:
1411e52966c0SLen Brown 	restarted++;
1412e52966c0SLen Brown 
1413c98d5d94SLen Brown 	retval = for_all_cpus(get_counters, EVEN_COUNTERS);
1414d91bb17cSLen Brown 	if (retval < -1) {
1415d91bb17cSLen Brown 		exit(retval);
1416d91bb17cSLen Brown 	} else if (retval == -1) {
1417e52966c0SLen Brown 		if (restarted > 1) {
1418e52966c0SLen Brown 			exit(retval);
1419e52966c0SLen Brown 		}
1420c98d5d94SLen Brown 		re_initialize();
1421c98d5d94SLen Brown 		goto restart;
1422c98d5d94SLen Brown 	}
1423e52966c0SLen Brown 	restarted = 0;
1424103a8feaSLen Brown 	gettimeofday(&tv_even, (struct timezone *)NULL);
1425103a8feaSLen Brown 
1426103a8feaSLen Brown 	while (1) {
1427c98d5d94SLen Brown 		if (for_all_proc_cpus(cpu_is_not_present)) {
1428103a8feaSLen Brown 			re_initialize();
1429103a8feaSLen Brown 			goto restart;
1430103a8feaSLen Brown 		}
1431103a8feaSLen Brown 		sleep(interval_sec);
1432c98d5d94SLen Brown 		retval = for_all_cpus(get_counters, ODD_COUNTERS);
1433d91bb17cSLen Brown 		if (retval < -1) {
1434d91bb17cSLen Brown 			exit(retval);
1435d91bb17cSLen Brown 		} else if (retval == -1) {
143615aaa346SLen Brown 			re_initialize();
143715aaa346SLen Brown 			goto restart;
143815aaa346SLen Brown 		}
1439103a8feaSLen Brown 		gettimeofday(&tv_odd, (struct timezone *)NULL);
1440103a8feaSLen Brown 		timersub(&tv_odd, &tv_even, &tv_delta);
1441c98d5d94SLen Brown 		for_all_cpus_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS);
1442c98d5d94SLen Brown 		compute_average(EVEN_COUNTERS);
1443c98d5d94SLen Brown 		format_all_counters(EVEN_COUNTERS);
1444c98d5d94SLen Brown 		flush_stdout();
144515aaa346SLen Brown 		sleep(interval_sec);
1446c98d5d94SLen Brown 		retval = for_all_cpus(get_counters, EVEN_COUNTERS);
1447d91bb17cSLen Brown 		if (retval < -1) {
1448d91bb17cSLen Brown 			exit(retval);
1449d91bb17cSLen Brown 		} else if (retval == -1) {
1450103a8feaSLen Brown 			re_initialize();
1451103a8feaSLen Brown 			goto restart;
1452103a8feaSLen Brown 		}
1453103a8feaSLen Brown 		gettimeofday(&tv_even, (struct timezone *)NULL);
1454103a8feaSLen Brown 		timersub(&tv_even, &tv_odd, &tv_delta);
1455c98d5d94SLen Brown 		for_all_cpus_2(delta_cpu, EVEN_COUNTERS, ODD_COUNTERS);
1456c98d5d94SLen Brown 		compute_average(ODD_COUNTERS);
1457c98d5d94SLen Brown 		format_all_counters(ODD_COUNTERS);
1458c98d5d94SLen Brown 		flush_stdout();
1459103a8feaSLen Brown 	}
1460103a8feaSLen Brown }
1461103a8feaSLen Brown 
1462103a8feaSLen Brown void check_dev_msr()
1463103a8feaSLen Brown {
1464103a8feaSLen Brown 	struct stat sb;
1465103a8feaSLen Brown 
1466b2c95d90SJosh Triplett 	if (stat("/dev/cpu/0/msr", &sb))
1467d7899447SLen Brown 		err(-5, "no /dev/cpu/0/msr, Try \"# modprobe msr\" ");
1468103a8feaSLen Brown }
1469103a8feaSLen Brown 
147098481e79SLen Brown void check_permissions()
1471103a8feaSLen Brown {
147298481e79SLen Brown 	struct __user_cap_header_struct cap_header_data;
147398481e79SLen Brown 	cap_user_header_t cap_header = &cap_header_data;
147498481e79SLen Brown 	struct __user_cap_data_struct cap_data_data;
147598481e79SLen Brown 	cap_user_data_t cap_data = &cap_data_data;
147698481e79SLen Brown 	extern int capget(cap_user_header_t hdrp, cap_user_data_t datap);
147798481e79SLen Brown 	int do_exit = 0;
147898481e79SLen Brown 
147998481e79SLen Brown 	/* check for CAP_SYS_RAWIO */
148098481e79SLen Brown 	cap_header->pid = getpid();
148198481e79SLen Brown 	cap_header->version = _LINUX_CAPABILITY_VERSION;
148298481e79SLen Brown 	if (capget(cap_header, cap_data) < 0)
148398481e79SLen Brown 		err(-6, "capget(2) failed");
148498481e79SLen Brown 
148598481e79SLen Brown 	if ((cap_data->effective & (1 << CAP_SYS_RAWIO)) == 0) {
148698481e79SLen Brown 		do_exit++;
148798481e79SLen Brown 		warnx("capget(CAP_SYS_RAWIO) failed,"
148898481e79SLen Brown 			" try \"# setcap cap_sys_rawio=ep %s\"", progname);
148998481e79SLen Brown 	}
149098481e79SLen Brown 
149198481e79SLen Brown 	/* test file permissions */
149298481e79SLen Brown 	if (euidaccess("/dev/cpu/0/msr", R_OK)) {
149398481e79SLen Brown 		do_exit++;
149498481e79SLen Brown 		warn("/dev/cpu/0/msr open failed, try chown or chmod +r /dev/cpu/*/msr");
149598481e79SLen Brown 	}
149698481e79SLen Brown 
149798481e79SLen Brown 	/* if all else fails, thell them to be root */
149898481e79SLen Brown 	if (do_exit)
1499b2c95d90SJosh Triplett 		if (getuid() != 0)
1500d7899447SLen Brown 			warnx("... or simply run as root");
150198481e79SLen Brown 
150298481e79SLen Brown 	if (do_exit)
150398481e79SLen Brown 		exit(-6);
1504103a8feaSLen Brown }
1505103a8feaSLen Brown 
1506d7899447SLen Brown /*
1507d7899447SLen Brown  * NHM adds support for additional MSRs:
1508d7899447SLen Brown  *
1509d7899447SLen Brown  * MSR_SMI_COUNT                   0x00000034
1510d7899447SLen Brown  *
1511d7899447SLen Brown  * MSR_NHM_PLATFORM_INFO           0x000000ce
1512d7899447SLen Brown  * MSR_NHM_SNB_PKG_CST_CFG_CTL     0x000000e2
1513d7899447SLen Brown  *
1514d7899447SLen Brown  * MSR_PKG_C3_RESIDENCY            0x000003f8
1515d7899447SLen Brown  * MSR_PKG_C6_RESIDENCY            0x000003f9
1516d7899447SLen Brown  * MSR_CORE_C3_RESIDENCY           0x000003fc
1517d7899447SLen Brown  * MSR_CORE_C6_RESIDENCY           0x000003fd
1518d7899447SLen Brown  *
1519d7899447SLen Brown  */
1520d7899447SLen Brown int has_nhm_msrs(unsigned int family, unsigned int model)
1521103a8feaSLen Brown {
1522103a8feaSLen Brown 	if (!genuine_intel)
1523103a8feaSLen Brown 		return 0;
1524103a8feaSLen Brown 
1525103a8feaSLen Brown 	if (family != 6)
1526103a8feaSLen Brown 		return 0;
1527103a8feaSLen Brown 
1528103a8feaSLen Brown 	switch (model) {
1529103a8feaSLen Brown 	case 0x1A:	/* Core i7, Xeon 5500 series - Bloomfield, Gainstown NHM-EP */
1530103a8feaSLen Brown 	case 0x1E:	/* Core i7 and i5 Processor - Clarksfield, Lynnfield, Jasper Forest */
1531103a8feaSLen Brown 	case 0x1F:	/* Core i7 and i5 Processor - Nehalem */
1532103a8feaSLen Brown 	case 0x25:	/* Westmere Client - Clarkdale, Arrandale */
1533103a8feaSLen Brown 	case 0x2C:	/* Westmere EP - Gulftown */
1534103a8feaSLen Brown 	case 0x2A:	/* SNB */
1535103a8feaSLen Brown 	case 0x2D:	/* SNB Xeon */
1536553575f1SLen Brown 	case 0x3A:	/* IVB */
15371300651bSLen Brown 	case 0x3E:	/* IVB Xeon */
153870b43400SLen Brown 	case 0x3C:	/* HSW */
1539e6f9bb3cSLen Brown 	case 0x3F:	/* HSX */
154070b43400SLen Brown 	case 0x45:	/* HSW */
1541149c2319SLen Brown 	case 0x46:	/* HSW */
1542144b44b1SLen Brown 	case 0x37:	/* BYT */
1543144b44b1SLen Brown 	case 0x4D:	/* AVN */
15444e8e863fSLen Brown 	case 0x3D:	/* BDW */
15454e8e863fSLen Brown 	case 0x4F:	/* BDX */
15464e8e863fSLen Brown 	case 0x56:	/* BDX-DE */
1547103a8feaSLen Brown 	case 0x2E:	/* Nehalem-EX Xeon - Beckton */
1548103a8feaSLen Brown 	case 0x2F:	/* Westmere-EX Xeon - Eagleton */
1549d7899447SLen Brown 		return 1;
1550103a8feaSLen Brown 	default:
1551103a8feaSLen Brown 		return 0;
1552103a8feaSLen Brown 	}
1553103a8feaSLen Brown }
1554d7899447SLen Brown int has_nhm_turbo_ratio_limit(unsigned int family, unsigned int model)
1555d7899447SLen Brown {
1556d7899447SLen Brown 	if (!has_nhm_msrs(family, model))
1557d7899447SLen Brown 		return 0;
1558d7899447SLen Brown 
1559d7899447SLen Brown 	switch (model) {
1560d7899447SLen Brown 	/* Nehalem compatible, but do not include turbo-ratio limit support */
1561d7899447SLen Brown 	case 0x2E:	/* Nehalem-EX Xeon - Beckton */
1562d7899447SLen Brown 	case 0x2F:	/* Westmere-EX Xeon - Eagleton */
1563d7899447SLen Brown 		return 0;
1564d7899447SLen Brown 	default:
1565d7899447SLen Brown 		return 1;
1566d7899447SLen Brown 	}
1567d7899447SLen Brown }
15686574a5d5SLen Brown int has_ivt_turbo_ratio_limit(unsigned int family, unsigned int model)
15696574a5d5SLen Brown {
15706574a5d5SLen Brown 	if (!genuine_intel)
15716574a5d5SLen Brown 		return 0;
15726574a5d5SLen Brown 
15736574a5d5SLen Brown 	if (family != 6)
15746574a5d5SLen Brown 		return 0;
15756574a5d5SLen Brown 
15766574a5d5SLen Brown 	switch (model) {
15776574a5d5SLen Brown 	case 0x3E:	/* IVB Xeon */
15786574a5d5SLen Brown 		return 1;
15796574a5d5SLen Brown 	default:
15806574a5d5SLen Brown 		return 0;
15816574a5d5SLen Brown 	}
15826574a5d5SLen Brown }
15836574a5d5SLen Brown 
1584889facbeSLen Brown /*
1585889facbeSLen Brown  * print_epb()
1586889facbeSLen Brown  * Decode the ENERGY_PERF_BIAS MSR
1587889facbeSLen Brown  */
1588889facbeSLen Brown int print_epb(struct thread_data *t, struct core_data *c, struct pkg_data *p)
1589889facbeSLen Brown {
1590889facbeSLen Brown 	unsigned long long msr;
1591889facbeSLen Brown 	char *epb_string;
1592889facbeSLen Brown 	int cpu;
1593889facbeSLen Brown 
1594889facbeSLen Brown 	if (!has_epb)
1595889facbeSLen Brown 		return 0;
1596889facbeSLen Brown 
1597889facbeSLen Brown 	cpu = t->cpu_id;
1598889facbeSLen Brown 
1599889facbeSLen Brown 	/* EPB is per-package */
1600889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
1601889facbeSLen Brown 		return 0;
1602889facbeSLen Brown 
1603889facbeSLen Brown 	if (cpu_migrate(cpu)) {
1604889facbeSLen Brown 		fprintf(stderr, "Could not migrate to CPU %d\n", cpu);
1605889facbeSLen Brown 		return -1;
1606889facbeSLen Brown 	}
1607889facbeSLen Brown 
1608889facbeSLen Brown 	if (get_msr(cpu, MSR_IA32_ENERGY_PERF_BIAS, &msr))
1609889facbeSLen Brown 		return 0;
1610889facbeSLen Brown 
1611889facbeSLen Brown 	switch (msr & 0x7) {
1612889facbeSLen Brown 	case ENERGY_PERF_BIAS_PERFORMANCE:
1613889facbeSLen Brown 		epb_string = "performance";
1614889facbeSLen Brown 		break;
1615889facbeSLen Brown 	case ENERGY_PERF_BIAS_NORMAL:
1616889facbeSLen Brown 		epb_string = "balanced";
1617889facbeSLen Brown 		break;
1618889facbeSLen Brown 	case ENERGY_PERF_BIAS_POWERSAVE:
1619889facbeSLen Brown 		epb_string = "powersave";
1620889facbeSLen Brown 		break;
1621889facbeSLen Brown 	default:
1622889facbeSLen Brown 		epb_string = "custom";
1623889facbeSLen Brown 		break;
1624889facbeSLen Brown 	}
1625889facbeSLen Brown 	fprintf(stderr, "cpu%d: MSR_IA32_ENERGY_PERF_BIAS: 0x%08llx (%s)\n", cpu, msr, epb_string);
1626889facbeSLen Brown 
1627889facbeSLen Brown 	return 0;
1628889facbeSLen Brown }
1629889facbeSLen Brown 
16303a9a941dSLen Brown /*
16313a9a941dSLen Brown  * print_perf_limit()
16323a9a941dSLen Brown  */
16333a9a941dSLen Brown int print_perf_limit(struct thread_data *t, struct core_data *c, struct pkg_data *p)
16343a9a941dSLen Brown {
16353a9a941dSLen Brown 	unsigned long long msr;
16363a9a941dSLen Brown 	int cpu;
16373a9a941dSLen Brown 
16383a9a941dSLen Brown 	cpu = t->cpu_id;
16393a9a941dSLen Brown 
16403a9a941dSLen Brown 	/* per-package */
16413a9a941dSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
16423a9a941dSLen Brown 		return 0;
16433a9a941dSLen Brown 
16443a9a941dSLen Brown 	if (cpu_migrate(cpu)) {
16453a9a941dSLen Brown 		fprintf(stderr, "Could not migrate to CPU %d\n", cpu);
16463a9a941dSLen Brown 		return -1;
16473a9a941dSLen Brown 	}
16483a9a941dSLen Brown 
16493a9a941dSLen Brown 	if (do_core_perf_limit_reasons) {
16503a9a941dSLen Brown 		get_msr(cpu, MSR_CORE_PERF_LIMIT_REASONS, &msr);
16513a9a941dSLen Brown 		fprintf(stderr, "cpu%d: MSR_CORE_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
16523a9a941dSLen Brown 		fprintf(stderr, " (Active: %s%s%s%s%s%s%s%s%s%s%s%s%s%s)",
16533a9a941dSLen Brown 			(msr & 1 << 0) ? "PROCHOT, " : "",
16543a9a941dSLen Brown 			(msr & 1 << 1) ? "ThermStatus, " : "",
16553a9a941dSLen Brown 			(msr & 1 << 2) ? "bit2, " : "",
16563a9a941dSLen Brown 			(msr & 1 << 4) ? "Graphics, " : "",
16573a9a941dSLen Brown 			(msr & 1 << 5) ? "Auto-HWP, " : "",
16583a9a941dSLen Brown 			(msr & 1 << 6) ? "VR-Therm, " : "",
16593a9a941dSLen Brown 			(msr & 1 << 8) ? "Amps, " : "",
16603a9a941dSLen Brown 			(msr & 1 << 9) ? "CorePwr, " : "",
16613a9a941dSLen Brown 			(msr & 1 << 10) ? "PkgPwrL1, " : "",
16623a9a941dSLen Brown 			(msr & 1 << 11) ? "PkgPwrL2, " : "",
16633a9a941dSLen Brown 			(msr & 1 << 12) ? "MultiCoreTurbo, " : "",
16643a9a941dSLen Brown 			(msr & 1 << 13) ? "Transitions, " : "",
16653a9a941dSLen Brown 			(msr & 1 << 14) ? "bit14, " : "",
16663a9a941dSLen Brown 			(msr & 1 << 15) ? "bit15, " : "");
16673a9a941dSLen Brown 		fprintf(stderr, " (Logged: %s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
16683a9a941dSLen Brown 			(msr & 1 << 16) ? "PROCHOT, " : "",
16693a9a941dSLen Brown 			(msr & 1 << 17) ? "ThermStatus, " : "",
16703a9a941dSLen Brown 			(msr & 1 << 18) ? "bit18, " : "",
16713a9a941dSLen Brown 			(msr & 1 << 20) ? "Graphics, " : "",
16723a9a941dSLen Brown 			(msr & 1 << 21) ? "Auto-HWP, " : "",
16733a9a941dSLen Brown 			(msr & 1 << 22) ? "VR-Therm, " : "",
16743a9a941dSLen Brown 			(msr & 1 << 24) ? "Amps, " : "",
16753a9a941dSLen Brown 			(msr & 1 << 25) ? "CorePwr, " : "",
16763a9a941dSLen Brown 			(msr & 1 << 26) ? "PkgPwrL1, " : "",
16773a9a941dSLen Brown 			(msr & 1 << 27) ? "PkgPwrL2, " : "",
16783a9a941dSLen Brown 			(msr & 1 << 28) ? "MultiCoreTurbo, " : "",
16793a9a941dSLen Brown 			(msr & 1 << 29) ? "Transitions, " : "",
16803a9a941dSLen Brown 			(msr & 1 << 30) ? "bit30, " : "",
16813a9a941dSLen Brown 			(msr & 1 << 31) ? "bit31, " : "");
16823a9a941dSLen Brown 
16833a9a941dSLen Brown 	}
16843a9a941dSLen Brown 	if (do_gfx_perf_limit_reasons) {
16853a9a941dSLen Brown 		get_msr(cpu, MSR_GFX_PERF_LIMIT_REASONS, &msr);
16863a9a941dSLen Brown 		fprintf(stderr, "cpu%d: MSR_GFX_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
16873a9a941dSLen Brown 		fprintf(stderr, " (Active: %s%s%s%s%s%s%s%s)",
16883a9a941dSLen Brown 			(msr & 1 << 0) ? "PROCHOT, " : "",
16893a9a941dSLen Brown 			(msr & 1 << 1) ? "ThermStatus, " : "",
16903a9a941dSLen Brown 			(msr & 1 << 4) ? "Graphics, " : "",
16913a9a941dSLen Brown 			(msr & 1 << 6) ? "VR-Therm, " : "",
16923a9a941dSLen Brown 			(msr & 1 << 8) ? "Amps, " : "",
16933a9a941dSLen Brown 			(msr & 1 << 9) ? "GFXPwr, " : "",
16943a9a941dSLen Brown 			(msr & 1 << 10) ? "PkgPwrL1, " : "",
16953a9a941dSLen Brown 			(msr & 1 << 11) ? "PkgPwrL2, " : "");
16963a9a941dSLen Brown 		fprintf(stderr, " (Logged: %s%s%s%s%s%s%s%s)\n",
16973a9a941dSLen Brown 			(msr & 1 << 16) ? "PROCHOT, " : "",
16983a9a941dSLen Brown 			(msr & 1 << 17) ? "ThermStatus, " : "",
16993a9a941dSLen Brown 			(msr & 1 << 20) ? "Graphics, " : "",
17003a9a941dSLen Brown 			(msr & 1 << 22) ? "VR-Therm, " : "",
17013a9a941dSLen Brown 			(msr & 1 << 24) ? "Amps, " : "",
17023a9a941dSLen Brown 			(msr & 1 << 25) ? "GFXPwr, " : "",
17033a9a941dSLen Brown 			(msr & 1 << 26) ? "PkgPwrL1, " : "",
17043a9a941dSLen Brown 			(msr & 1 << 27) ? "PkgPwrL2, " : "");
17053a9a941dSLen Brown 	}
17063a9a941dSLen Brown 	if (do_ring_perf_limit_reasons) {
17073a9a941dSLen Brown 		get_msr(cpu, MSR_RING_PERF_LIMIT_REASONS, &msr);
17083a9a941dSLen Brown 		fprintf(stderr, "cpu%d: MSR_RING_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
17093a9a941dSLen Brown 		fprintf(stderr, " (Active: %s%s%s%s%s%s)",
17103a9a941dSLen Brown 			(msr & 1 << 0) ? "PROCHOT, " : "",
17113a9a941dSLen Brown 			(msr & 1 << 1) ? "ThermStatus, " : "",
17123a9a941dSLen Brown 			(msr & 1 << 6) ? "VR-Therm, " : "",
17133a9a941dSLen Brown 			(msr & 1 << 8) ? "Amps, " : "",
17143a9a941dSLen Brown 			(msr & 1 << 10) ? "PkgPwrL1, " : "",
17153a9a941dSLen Brown 			(msr & 1 << 11) ? "PkgPwrL2, " : "");
17163a9a941dSLen Brown 		fprintf(stderr, " (Logged: %s%s%s%s%s%s)\n",
17173a9a941dSLen Brown 			(msr & 1 << 16) ? "PROCHOT, " : "",
17183a9a941dSLen Brown 			(msr & 1 << 17) ? "ThermStatus, " : "",
17193a9a941dSLen Brown 			(msr & 1 << 22) ? "VR-Therm, " : "",
17203a9a941dSLen Brown 			(msr & 1 << 24) ? "Amps, " : "",
17213a9a941dSLen Brown 			(msr & 1 << 26) ? "PkgPwrL1, " : "",
17223a9a941dSLen Brown 			(msr & 1 << 27) ? "PkgPwrL2, " : "");
17233a9a941dSLen Brown 	}
17243a9a941dSLen Brown 	return 0;
17253a9a941dSLen Brown }
17263a9a941dSLen Brown 
1727889facbeSLen Brown #define	RAPL_POWER_GRANULARITY	0x7FFF	/* 15 bit power granularity */
1728889facbeSLen Brown #define	RAPL_TIME_GRANULARITY	0x3F /* 6 bit time granularity */
1729889facbeSLen Brown 
1730144b44b1SLen Brown double get_tdp(model)
1731144b44b1SLen Brown {
1732144b44b1SLen Brown 	unsigned long long msr;
1733144b44b1SLen Brown 
1734144b44b1SLen Brown 	if (do_rapl & RAPL_PKG_POWER_INFO)
1735144b44b1SLen Brown 		if (!get_msr(0, MSR_PKG_POWER_INFO, &msr))
1736144b44b1SLen Brown 			return ((msr >> 0) & RAPL_POWER_GRANULARITY) * rapl_power_units;
1737144b44b1SLen Brown 
1738144b44b1SLen Brown 	switch (model) {
1739144b44b1SLen Brown 	case 0x37:
1740144b44b1SLen Brown 	case 0x4D:
1741144b44b1SLen Brown 		return 30.0;
1742144b44b1SLen Brown 	default:
1743144b44b1SLen Brown 		return 135.0;
1744144b44b1SLen Brown 	}
1745144b44b1SLen Brown }
1746144b44b1SLen Brown 
1747144b44b1SLen Brown 
1748889facbeSLen Brown /*
1749889facbeSLen Brown  * rapl_probe()
1750889facbeSLen Brown  *
1751144b44b1SLen Brown  * sets do_rapl, rapl_power_units, rapl_energy_units, rapl_time_units
1752889facbeSLen Brown  */
1753889facbeSLen Brown void rapl_probe(unsigned int family, unsigned int model)
1754889facbeSLen Brown {
1755889facbeSLen Brown 	unsigned long long msr;
1756144b44b1SLen Brown 	unsigned int time_unit;
1757889facbeSLen Brown 	double tdp;
1758889facbeSLen Brown 
1759889facbeSLen Brown 	if (!genuine_intel)
1760889facbeSLen Brown 		return;
1761889facbeSLen Brown 
1762889facbeSLen Brown 	if (family != 6)
1763889facbeSLen Brown 		return;
1764889facbeSLen Brown 
1765889facbeSLen Brown 	switch (model) {
1766889facbeSLen Brown 	case 0x2A:
1767889facbeSLen Brown 	case 0x3A:
176870b43400SLen Brown 	case 0x3C:	/* HSW */
176970b43400SLen Brown 	case 0x45:	/* HSW */
1770149c2319SLen Brown 	case 0x46:	/* HSW */
17714e8e863fSLen Brown 	case 0x3D:	/* BDW */
1772144b44b1SLen Brown 		do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_GFX | RAPL_PKG_POWER_INFO;
1773889facbeSLen Brown 		break;
1774e6f9bb3cSLen Brown 	case 0x3F:	/* HSX */
17754e8e863fSLen Brown 	case 0x4F:	/* BDX */
17764e8e863fSLen Brown 	case 0x56:	/* BDX-DE */
1777e6f9bb3cSLen Brown 		do_rapl = RAPL_PKG | RAPL_DRAM | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_PKG_POWER_INFO;
1778e6f9bb3cSLen Brown 		break;
1779889facbeSLen Brown 	case 0x2D:
1780889facbeSLen Brown 	case 0x3E:
1781144b44b1SLen Brown 		do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_DRAM | RAPL_PKG_PERF_STATUS | RAPL_DRAM_PERF_STATUS | RAPL_PKG_POWER_INFO;
1782144b44b1SLen Brown 		break;
1783144b44b1SLen Brown 	case 0x37:	/* BYT */
1784144b44b1SLen Brown 	case 0x4D:	/* AVN */
1785144b44b1SLen Brown 		do_rapl = RAPL_PKG | RAPL_CORES ;
1786889facbeSLen Brown 		break;
1787889facbeSLen Brown 	default:
1788889facbeSLen Brown 		return;
1789889facbeSLen Brown 	}
1790889facbeSLen Brown 
1791889facbeSLen Brown 	/* units on package 0, verify later other packages match */
1792889facbeSLen Brown 	if (get_msr(0, MSR_RAPL_POWER_UNIT, &msr))
1793889facbeSLen Brown 		return;
1794889facbeSLen Brown 
1795889facbeSLen Brown 	rapl_power_units = 1.0 / (1 << (msr & 0xF));
1796144b44b1SLen Brown 	if (model == 0x37)
1797144b44b1SLen Brown 		rapl_energy_units = 1.0 * (1 << (msr >> 8 & 0x1F)) / 1000000;
1798144b44b1SLen Brown 	else
1799889facbeSLen Brown 		rapl_energy_units = 1.0 / (1 << (msr >> 8 & 0x1F));
1800889facbeSLen Brown 
1801144b44b1SLen Brown 	time_unit = msr >> 16 & 0xF;
1802144b44b1SLen Brown 	if (time_unit == 0)
1803144b44b1SLen Brown 		time_unit = 0xA;
1804889facbeSLen Brown 
1805144b44b1SLen Brown 	rapl_time_units = 1.0 / (1 << (time_unit));
1806144b44b1SLen Brown 
1807144b44b1SLen Brown 	tdp = get_tdp(model);
1808889facbeSLen Brown 
1809889facbeSLen Brown 	rapl_joule_counter_range = 0xFFFFFFFF * rapl_energy_units / tdp;
1810889facbeSLen Brown 	if (verbose)
1811144b44b1SLen Brown 		fprintf(stderr, "RAPL: %.0f sec. Joule Counter Range, at %.0f Watts\n", rapl_joule_counter_range, tdp);
1812889facbeSLen Brown 
1813889facbeSLen Brown 	return;
1814889facbeSLen Brown }
1815889facbeSLen Brown 
18163a9a941dSLen Brown void perf_limit_reasons_probe(family, model)
18173a9a941dSLen Brown {
18183a9a941dSLen Brown 	if (!genuine_intel)
18193a9a941dSLen Brown 		return;
18203a9a941dSLen Brown 
18213a9a941dSLen Brown 	if (family != 6)
18223a9a941dSLen Brown 		return;
18233a9a941dSLen Brown 
18243a9a941dSLen Brown 	switch (model) {
18253a9a941dSLen Brown 	case 0x3C:	/* HSW */
18263a9a941dSLen Brown 	case 0x45:	/* HSW */
18273a9a941dSLen Brown 	case 0x46:	/* HSW */
18283a9a941dSLen Brown 		do_gfx_perf_limit_reasons = 1;
18293a9a941dSLen Brown 	case 0x3F:	/* HSX */
18303a9a941dSLen Brown 		do_core_perf_limit_reasons = 1;
18313a9a941dSLen Brown 		do_ring_perf_limit_reasons = 1;
18323a9a941dSLen Brown 	default:
18333a9a941dSLen Brown 		return;
18343a9a941dSLen Brown 	}
18353a9a941dSLen Brown }
18363a9a941dSLen Brown 
1837889facbeSLen Brown int print_thermal(struct thread_data *t, struct core_data *c, struct pkg_data *p)
1838889facbeSLen Brown {
1839889facbeSLen Brown 	unsigned long long msr;
1840889facbeSLen Brown 	unsigned int dts;
1841889facbeSLen Brown 	int cpu;
1842889facbeSLen Brown 
1843889facbeSLen Brown 	if (!(do_dts || do_ptm))
1844889facbeSLen Brown 		return 0;
1845889facbeSLen Brown 
1846889facbeSLen Brown 	cpu = t->cpu_id;
1847889facbeSLen Brown 
1848889facbeSLen Brown 	/* DTS is per-core, no need to print for each thread */
1849889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
1850889facbeSLen Brown 		return 0;
1851889facbeSLen Brown 
1852889facbeSLen Brown 	if (cpu_migrate(cpu)) {
1853889facbeSLen Brown 		fprintf(stderr, "Could not migrate to CPU %d\n", cpu);
1854889facbeSLen Brown 		return -1;
1855889facbeSLen Brown 	}
1856889facbeSLen Brown 
1857889facbeSLen Brown 	if (do_ptm && (t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE)) {
1858889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_STATUS, &msr))
1859889facbeSLen Brown 			return 0;
1860889facbeSLen Brown 
1861889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
1862889facbeSLen Brown 		fprintf(stderr, "cpu%d: MSR_IA32_PACKAGE_THERM_STATUS: 0x%08llx (%d C)\n",
1863889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts);
1864889facbeSLen Brown 
1865889facbeSLen Brown #ifdef	THERM_DEBUG
1866889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT, &msr))
1867889facbeSLen Brown 			return 0;
1868889facbeSLen Brown 
1869889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
1870889facbeSLen Brown 		dts2 = (msr >> 8) & 0x7F;
1871889facbeSLen Brown 		fprintf(stderr, "cpu%d: MSR_IA32_PACKAGE_THERM_INTERRUPT: 0x%08llx (%d C, %d C)\n",
1872889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts, tcc_activation_temp - dts2);
1873889facbeSLen Brown #endif
1874889facbeSLen Brown 	}
1875889facbeSLen Brown 
1876889facbeSLen Brown 
1877889facbeSLen Brown 	if (do_dts) {
1878889facbeSLen Brown 		unsigned int resolution;
1879889facbeSLen Brown 
1880889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_THERM_STATUS, &msr))
1881889facbeSLen Brown 			return 0;
1882889facbeSLen Brown 
1883889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
1884889facbeSLen Brown 		resolution = (msr >> 27) & 0xF;
1885889facbeSLen Brown 		fprintf(stderr, "cpu%d: MSR_IA32_THERM_STATUS: 0x%08llx (%d C +/- %d)\n",
1886889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts, resolution);
1887889facbeSLen Brown 
1888889facbeSLen Brown #ifdef THERM_DEBUG
1889889facbeSLen Brown 		if (get_msr(cpu, MSR_IA32_THERM_INTERRUPT, &msr))
1890889facbeSLen Brown 			return 0;
1891889facbeSLen Brown 
1892889facbeSLen Brown 		dts = (msr >> 16) & 0x7F;
1893889facbeSLen Brown 		dts2 = (msr >> 8) & 0x7F;
1894889facbeSLen Brown 		fprintf(stderr, "cpu%d: MSR_IA32_THERM_INTERRUPT: 0x%08llx (%d C, %d C)\n",
1895889facbeSLen Brown 			cpu, msr, tcc_activation_temp - dts, tcc_activation_temp - dts2);
1896889facbeSLen Brown #endif
1897889facbeSLen Brown 	}
1898889facbeSLen Brown 
1899889facbeSLen Brown 	return 0;
1900889facbeSLen Brown }
1901889facbeSLen Brown 
1902889facbeSLen Brown void print_power_limit_msr(int cpu, unsigned long long msr, char *label)
1903889facbeSLen Brown {
1904889facbeSLen Brown 	fprintf(stderr, "cpu%d: %s: %sabled (%f Watts, %f sec, clamp %sabled)\n",
1905889facbeSLen Brown 		cpu, label,
1906889facbeSLen Brown 		((msr >> 15) & 1) ? "EN" : "DIS",
1907889facbeSLen Brown 		((msr >> 0) & 0x7FFF) * rapl_power_units,
1908889facbeSLen Brown 		(1.0 + (((msr >> 22) & 0x3)/4.0)) * (1 << ((msr >> 17) & 0x1F)) * rapl_time_units,
1909889facbeSLen Brown 		(((msr >> 16) & 1) ? "EN" : "DIS"));
1910889facbeSLen Brown 
1911889facbeSLen Brown 	return;
1912889facbeSLen Brown }
1913889facbeSLen Brown 
1914889facbeSLen Brown int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p)
1915889facbeSLen Brown {
1916889facbeSLen Brown 	unsigned long long msr;
1917889facbeSLen Brown 	int cpu;
1918889facbeSLen Brown 
1919889facbeSLen Brown 	if (!do_rapl)
1920889facbeSLen Brown 		return 0;
1921889facbeSLen Brown 
1922889facbeSLen Brown 	/* RAPL counters are per package, so print only for 1st thread/package */
1923889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
1924889facbeSLen Brown 		return 0;
1925889facbeSLen Brown 
1926889facbeSLen Brown 	cpu = t->cpu_id;
1927889facbeSLen Brown 	if (cpu_migrate(cpu)) {
1928889facbeSLen Brown 		fprintf(stderr, "Could not migrate to CPU %d\n", cpu);
1929889facbeSLen Brown 		return -1;
1930889facbeSLen Brown 	}
1931889facbeSLen Brown 
1932889facbeSLen Brown 	if (get_msr(cpu, MSR_RAPL_POWER_UNIT, &msr))
1933889facbeSLen Brown 		return -1;
1934889facbeSLen Brown 
1935889facbeSLen Brown 	if (verbose) {
1936889facbeSLen Brown 		fprintf(stderr, "cpu%d: MSR_RAPL_POWER_UNIT: 0x%08llx "
1937889facbeSLen Brown 			"(%f Watts, %f Joules, %f sec.)\n", cpu, msr,
1938144b44b1SLen Brown 			rapl_power_units, rapl_energy_units, rapl_time_units);
1939889facbeSLen Brown 	}
1940144b44b1SLen Brown 	if (do_rapl & RAPL_PKG_POWER_INFO) {
1941144b44b1SLen Brown 
1942889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_POWER_INFO, &msr))
1943889facbeSLen Brown                 	return -5;
1944889facbeSLen Brown 
1945889facbeSLen Brown 
1946889facbeSLen Brown 		fprintf(stderr, "cpu%d: MSR_PKG_POWER_INFO: 0x%08llx (%.0f W TDP, RAPL %.0f - %.0f W, %f sec.)\n",
1947889facbeSLen Brown 			cpu, msr,
1948889facbeSLen Brown 			((msr >>  0) & RAPL_POWER_GRANULARITY) * rapl_power_units,
1949889facbeSLen Brown 			((msr >> 16) & RAPL_POWER_GRANULARITY) * rapl_power_units,
1950889facbeSLen Brown 			((msr >> 32) & RAPL_POWER_GRANULARITY) * rapl_power_units,
1951889facbeSLen Brown 			((msr >> 48) & RAPL_TIME_GRANULARITY) * rapl_time_units);
1952889facbeSLen Brown 
1953144b44b1SLen Brown 	}
1954144b44b1SLen Brown 	if (do_rapl & RAPL_PKG) {
1955144b44b1SLen Brown 
1956889facbeSLen Brown 		if (get_msr(cpu, MSR_PKG_POWER_LIMIT, &msr))
1957889facbeSLen Brown 			return -9;
1958889facbeSLen Brown 
1959889facbeSLen Brown 		fprintf(stderr, "cpu%d: MSR_PKG_POWER_LIMIT: 0x%08llx (%slocked)\n",
1960889facbeSLen Brown 			cpu, msr, (msr >> 63) & 1 ? "": "UN");
1961889facbeSLen Brown 
1962889facbeSLen Brown 		print_power_limit_msr(cpu, msr, "PKG Limit #1");
1963889facbeSLen Brown 		fprintf(stderr, "cpu%d: PKG Limit #2: %sabled (%f Watts, %f* sec, clamp %sabled)\n",
1964889facbeSLen Brown 			cpu,
1965889facbeSLen Brown 			((msr >> 47) & 1) ? "EN" : "DIS",
1966889facbeSLen Brown 			((msr >> 32) & 0x7FFF) * rapl_power_units,
1967889facbeSLen Brown 			(1.0 + (((msr >> 54) & 0x3)/4.0)) * (1 << ((msr >> 49) & 0x1F)) * rapl_time_units,
1968889facbeSLen Brown 			((msr >> 48) & 1) ? "EN" : "DIS");
1969889facbeSLen Brown 	}
1970889facbeSLen Brown 
1971889facbeSLen Brown 	if (do_rapl & RAPL_DRAM) {
1972889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_POWER_INFO, &msr))
1973889facbeSLen Brown                 	return -6;
1974889facbeSLen Brown 
1975889facbeSLen Brown 
1976889facbeSLen Brown 		fprintf(stderr, "cpu%d: MSR_DRAM_POWER_INFO,: 0x%08llx (%.0f W TDP, RAPL %.0f - %.0f W, %f sec.)\n",
1977889facbeSLen Brown 			cpu, msr,
1978889facbeSLen Brown 			((msr >>  0) & RAPL_POWER_GRANULARITY) * rapl_power_units,
1979889facbeSLen Brown 			((msr >> 16) & RAPL_POWER_GRANULARITY) * rapl_power_units,
1980889facbeSLen Brown 			((msr >> 32) & RAPL_POWER_GRANULARITY) * rapl_power_units,
1981889facbeSLen Brown 			((msr >> 48) & RAPL_TIME_GRANULARITY) * rapl_time_units);
1982889facbeSLen Brown 
1983889facbeSLen Brown 
1984889facbeSLen Brown 		if (get_msr(cpu, MSR_DRAM_POWER_LIMIT, &msr))
1985889facbeSLen Brown 			return -9;
1986889facbeSLen Brown 		fprintf(stderr, "cpu%d: MSR_DRAM_POWER_LIMIT: 0x%08llx (%slocked)\n",
1987889facbeSLen Brown 				cpu, msr, (msr >> 31) & 1 ? "": "UN");
1988889facbeSLen Brown 
1989889facbeSLen Brown 		print_power_limit_msr(cpu, msr, "DRAM Limit");
1990889facbeSLen Brown 	}
1991144b44b1SLen Brown 	if (do_rapl & RAPL_CORE_POLICY) {
1992889facbeSLen Brown 		if (verbose) {
1993889facbeSLen Brown 			if (get_msr(cpu, MSR_PP0_POLICY, &msr))
1994889facbeSLen Brown 				return -7;
1995889facbeSLen Brown 
1996889facbeSLen Brown 			fprintf(stderr, "cpu%d: MSR_PP0_POLICY: %lld\n", cpu, msr & 0xF);
1997144b44b1SLen Brown 		}
1998144b44b1SLen Brown 	}
1999144b44b1SLen Brown 	if (do_rapl & RAPL_CORES) {
2000144b44b1SLen Brown 		if (verbose) {
2001889facbeSLen Brown 
2002889facbeSLen Brown 			if (get_msr(cpu, MSR_PP0_POWER_LIMIT, &msr))
2003889facbeSLen Brown 				return -9;
2004889facbeSLen Brown 			fprintf(stderr, "cpu%d: MSR_PP0_POWER_LIMIT: 0x%08llx (%slocked)\n",
2005889facbeSLen Brown 					cpu, msr, (msr >> 31) & 1 ? "": "UN");
2006889facbeSLen Brown 			print_power_limit_msr(cpu, msr, "Cores Limit");
2007889facbeSLen Brown 		}
2008889facbeSLen Brown 	}
2009889facbeSLen Brown 	if (do_rapl & RAPL_GFX) {
2010889facbeSLen Brown 		if (verbose) {
2011889facbeSLen Brown 			if (get_msr(cpu, MSR_PP1_POLICY, &msr))
2012889facbeSLen Brown 				return -8;
2013889facbeSLen Brown 
2014889facbeSLen Brown 			fprintf(stderr, "cpu%d: MSR_PP1_POLICY: %lld\n", cpu, msr & 0xF);
2015889facbeSLen Brown 
2016889facbeSLen Brown 			if (get_msr(cpu, MSR_PP1_POWER_LIMIT, &msr))
2017889facbeSLen Brown 				return -9;
2018889facbeSLen Brown 			fprintf(stderr, "cpu%d: MSR_PP1_POWER_LIMIT: 0x%08llx (%slocked)\n",
2019889facbeSLen Brown 					cpu, msr, (msr >> 31) & 1 ? "": "UN");
2020889facbeSLen Brown 			print_power_limit_msr(cpu, msr, "GFX Limit");
2021889facbeSLen Brown 		}
2022889facbeSLen Brown 	}
2023889facbeSLen Brown 	return 0;
2024889facbeSLen Brown }
2025889facbeSLen Brown 
2026d7899447SLen Brown /*
2027d7899447SLen Brown  * SNB adds support for additional MSRs:
2028d7899447SLen Brown  *
2029d7899447SLen Brown  * MSR_PKG_C7_RESIDENCY            0x000003fa
2030d7899447SLen Brown  * MSR_CORE_C7_RESIDENCY           0x000003fe
2031d7899447SLen Brown  * MSR_PKG_C2_RESIDENCY            0x0000060d
2032d7899447SLen Brown  */
2033103a8feaSLen Brown 
2034d7899447SLen Brown int has_snb_msrs(unsigned int family, unsigned int model)
2035103a8feaSLen Brown {
2036103a8feaSLen Brown 	if (!genuine_intel)
2037103a8feaSLen Brown 		return 0;
2038103a8feaSLen Brown 
2039103a8feaSLen Brown 	switch (model) {
2040103a8feaSLen Brown 	case 0x2A:
2041103a8feaSLen Brown 	case 0x2D:
2042650a37f3SLen Brown 	case 0x3A:	/* IVB */
20431300651bSLen Brown 	case 0x3E:	/* IVB Xeon */
204470b43400SLen Brown 	case 0x3C:	/* HSW */
204570b43400SLen Brown 	case 0x3F:	/* HSW */
204670b43400SLen Brown 	case 0x45:	/* HSW */
2047149c2319SLen Brown 	case 0x46:	/* HSW */
20484e8e863fSLen Brown 	case 0x3D:	/* BDW */
20494e8e863fSLen Brown 	case 0x4F:	/* BDX */
20504e8e863fSLen Brown 	case 0x56:	/* BDX-DE */
2051103a8feaSLen Brown 		return 1;
2052103a8feaSLen Brown 	}
2053103a8feaSLen Brown 	return 0;
2054103a8feaSLen Brown }
2055103a8feaSLen Brown 
2056d7899447SLen Brown /*
2057d7899447SLen Brown  * HSW adds support for additional MSRs:
2058d7899447SLen Brown  *
2059d7899447SLen Brown  * MSR_PKG_C8_RESIDENCY            0x00000630
2060d7899447SLen Brown  * MSR_PKG_C9_RESIDENCY            0x00000631
2061d7899447SLen Brown  * MSR_PKG_C10_RESIDENCY           0x00000632
2062d7899447SLen Brown  */
2063d7899447SLen Brown int has_hsw_msrs(unsigned int family, unsigned int model)
2064ca58710fSKristen Carlson Accardi {
2065ca58710fSKristen Carlson Accardi 	if (!genuine_intel)
2066ca58710fSKristen Carlson Accardi 		return 0;
2067ca58710fSKristen Carlson Accardi 
2068ca58710fSKristen Carlson Accardi 	switch (model) {
20694e8e863fSLen Brown 	case 0x45:	/* HSW */
20704e8e863fSLen Brown 	case 0x3D:	/* BDW */
2071ca58710fSKristen Carlson Accardi 		return 1;
2072ca58710fSKristen Carlson Accardi 	}
2073ca58710fSKristen Carlson Accardi 	return 0;
2074ca58710fSKristen Carlson Accardi }
2075ca58710fSKristen Carlson Accardi 
2076ca58710fSKristen Carlson Accardi 
2077144b44b1SLen Brown int is_slm(unsigned int family, unsigned int model)
2078144b44b1SLen Brown {
2079144b44b1SLen Brown 	if (!genuine_intel)
2080144b44b1SLen Brown 		return 0;
2081144b44b1SLen Brown 	switch (model) {
2082144b44b1SLen Brown 	case 0x37:	/* BYT */
2083144b44b1SLen Brown 	case 0x4D:	/* AVN */
2084144b44b1SLen Brown 		return 1;
2085144b44b1SLen Brown 	}
2086144b44b1SLen Brown 	return 0;
2087144b44b1SLen Brown }
2088144b44b1SLen Brown 
2089144b44b1SLen Brown #define SLM_BCLK_FREQS 5
2090144b44b1SLen Brown double slm_freq_table[SLM_BCLK_FREQS] = { 83.3, 100.0, 133.3, 116.7, 80.0};
2091144b44b1SLen Brown 
2092144b44b1SLen Brown double slm_bclk(void)
2093144b44b1SLen Brown {
2094144b44b1SLen Brown 	unsigned long long msr = 3;
2095144b44b1SLen Brown 	unsigned int i;
2096144b44b1SLen Brown 	double freq;
2097144b44b1SLen Brown 
2098144b44b1SLen Brown 	if (get_msr(0, MSR_FSB_FREQ, &msr))
2099144b44b1SLen Brown 		fprintf(stderr, "SLM BCLK: unknown\n");
2100144b44b1SLen Brown 
2101144b44b1SLen Brown 	i = msr & 0xf;
2102144b44b1SLen Brown 	if (i >= SLM_BCLK_FREQS) {
2103144b44b1SLen Brown 		fprintf(stderr, "SLM BCLK[%d] invalid\n", i);
2104144b44b1SLen Brown 		msr = 3;
2105144b44b1SLen Brown 	}
2106144b44b1SLen Brown 	freq = slm_freq_table[i];
2107144b44b1SLen Brown 
2108144b44b1SLen Brown 	fprintf(stderr, "SLM BCLK: %.1f Mhz\n", freq);
2109144b44b1SLen Brown 
2110144b44b1SLen Brown 	return freq;
2111144b44b1SLen Brown }
2112144b44b1SLen Brown 
2113103a8feaSLen Brown double discover_bclk(unsigned int family, unsigned int model)
2114103a8feaSLen Brown {
2115d7899447SLen Brown 	if (has_snb_msrs(family, model))
2116103a8feaSLen Brown 		return 100.00;
2117144b44b1SLen Brown 	else if (is_slm(family, model))
2118144b44b1SLen Brown 		return slm_bclk();
2119103a8feaSLen Brown 	else
2120103a8feaSLen Brown 		return 133.33;
2121103a8feaSLen Brown }
2122103a8feaSLen Brown 
2123889facbeSLen Brown /*
2124889facbeSLen Brown  * MSR_IA32_TEMPERATURE_TARGET indicates the temperature where
2125889facbeSLen Brown  * the Thermal Control Circuit (TCC) activates.
2126889facbeSLen Brown  * This is usually equal to tjMax.
2127889facbeSLen Brown  *
2128889facbeSLen Brown  * Older processors do not have this MSR, so there we guess,
2129889facbeSLen Brown  * but also allow cmdline over-ride with -T.
2130889facbeSLen Brown  *
2131889facbeSLen Brown  * Several MSR temperature values are in units of degrees-C
2132889facbeSLen Brown  * below this value, including the Digital Thermal Sensor (DTS),
2133889facbeSLen Brown  * Package Thermal Management Sensor (PTM), and thermal event thresholds.
2134889facbeSLen Brown  */
2135889facbeSLen Brown int set_temperature_target(struct thread_data *t, struct core_data *c, struct pkg_data *p)
2136889facbeSLen Brown {
2137889facbeSLen Brown 	unsigned long long msr;
2138889facbeSLen Brown 	unsigned int target_c_local;
2139889facbeSLen Brown 	int cpu;
2140889facbeSLen Brown 
2141889facbeSLen Brown 	/* tcc_activation_temp is used only for dts or ptm */
2142889facbeSLen Brown 	if (!(do_dts || do_ptm))
2143889facbeSLen Brown 		return 0;
2144889facbeSLen Brown 
2145889facbeSLen Brown 	/* this is a per-package concept */
2146889facbeSLen Brown 	if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
2147889facbeSLen Brown 		return 0;
2148889facbeSLen Brown 
2149889facbeSLen Brown 	cpu = t->cpu_id;
2150889facbeSLen Brown 	if (cpu_migrate(cpu)) {
2151889facbeSLen Brown 		fprintf(stderr, "Could not migrate to CPU %d\n", cpu);
2152889facbeSLen Brown 		return -1;
2153889facbeSLen Brown 	}
2154889facbeSLen Brown 
2155889facbeSLen Brown 	if (tcc_activation_temp_override != 0) {
2156889facbeSLen Brown 		tcc_activation_temp = tcc_activation_temp_override;
2157889facbeSLen Brown 		fprintf(stderr, "cpu%d: Using cmdline TCC Target (%d C)\n",
2158889facbeSLen Brown 			cpu, tcc_activation_temp);
2159889facbeSLen Brown 		return 0;
2160889facbeSLen Brown 	}
2161889facbeSLen Brown 
2162889facbeSLen Brown 	/* Temperature Target MSR is Nehalem and newer only */
2163d7899447SLen Brown 	if (!do_nhm_platform_info)
2164889facbeSLen Brown 		goto guess;
2165889facbeSLen Brown 
2166889facbeSLen Brown 	if (get_msr(0, MSR_IA32_TEMPERATURE_TARGET, &msr))
2167889facbeSLen Brown 		goto guess;
2168889facbeSLen Brown 
21693482124aSJean Delvare 	target_c_local = (msr >> 16) & 0xFF;
2170889facbeSLen Brown 
2171889facbeSLen Brown 	if (verbose)
2172889facbeSLen Brown 		fprintf(stderr, "cpu%d: MSR_IA32_TEMPERATURE_TARGET: 0x%08llx (%d C)\n",
2173889facbeSLen Brown 			cpu, msr, target_c_local);
2174889facbeSLen Brown 
21753482124aSJean Delvare 	if (!target_c_local)
2176889facbeSLen Brown 		goto guess;
2177889facbeSLen Brown 
2178889facbeSLen Brown 	tcc_activation_temp = target_c_local;
2179889facbeSLen Brown 
2180889facbeSLen Brown 	return 0;
2181889facbeSLen Brown 
2182889facbeSLen Brown guess:
2183889facbeSLen Brown 	tcc_activation_temp = TJMAX_DEFAULT;
2184889facbeSLen Brown 	fprintf(stderr, "cpu%d: Guessing tjMax %d C, Please use -T to specify\n",
2185889facbeSLen Brown 		cpu, tcc_activation_temp);
2186889facbeSLen Brown 
2187889facbeSLen Brown 	return 0;
2188889facbeSLen Brown }
2189103a8feaSLen Brown void check_cpuid()
2190103a8feaSLen Brown {
2191103a8feaSLen Brown 	unsigned int eax, ebx, ecx, edx, max_level;
2192103a8feaSLen Brown 	unsigned int fms, family, model, stepping;
2193103a8feaSLen Brown 
2194103a8feaSLen Brown 	eax = ebx = ecx = edx = 0;
2195103a8feaSLen Brown 
21962b92865eSJosh Triplett 	__get_cpuid(0, &max_level, &ebx, &ecx, &edx);
2197103a8feaSLen Brown 
2198103a8feaSLen Brown 	if (ebx == 0x756e6547 && edx == 0x49656e69 && ecx == 0x6c65746e)
2199103a8feaSLen Brown 		genuine_intel = 1;
2200103a8feaSLen Brown 
2201103a8feaSLen Brown 	if (verbose)
2202889facbeSLen Brown 		fprintf(stderr, "CPUID(0): %.4s%.4s%.4s ",
2203103a8feaSLen Brown 			(char *)&ebx, (char *)&edx, (char *)&ecx);
2204103a8feaSLen Brown 
22052b92865eSJosh Triplett 	__get_cpuid(1, &fms, &ebx, &ecx, &edx);
2206103a8feaSLen Brown 	family = (fms >> 8) & 0xf;
2207103a8feaSLen Brown 	model = (fms >> 4) & 0xf;
2208103a8feaSLen Brown 	stepping = fms & 0xf;
2209103a8feaSLen Brown 	if (family == 6 || family == 0xf)
2210103a8feaSLen Brown 		model += ((fms >> 16) & 0xf) << 4;
2211103a8feaSLen Brown 
2212103a8feaSLen Brown 	if (verbose)
2213103a8feaSLen Brown 		fprintf(stderr, "%d CPUID levels; family:model:stepping 0x%x:%x:%x (%d:%d:%d)\n",
2214103a8feaSLen Brown 			max_level, family, model, stepping, family, model, stepping);
2215103a8feaSLen Brown 
2216b2c95d90SJosh Triplett 	if (!(edx & (1 << 5)))
2217b2c95d90SJosh Triplett 		errx(1, "CPUID: no MSR");
2218103a8feaSLen Brown 
2219103a8feaSLen Brown 	/*
2220103a8feaSLen Brown 	 * check max extended function levels of CPUID.
2221103a8feaSLen Brown 	 * This is needed to check for invariant TSC.
2222103a8feaSLen Brown 	 * This check is valid for both Intel and AMD.
2223103a8feaSLen Brown 	 */
2224103a8feaSLen Brown 	ebx = ecx = edx = 0;
22252b92865eSJosh Triplett 	__get_cpuid(0x80000000, &max_level, &ebx, &ecx, &edx);
2226103a8feaSLen Brown 
2227d7899447SLen Brown 	if (max_level >= 0x80000007) {
2228103a8feaSLen Brown 
2229103a8feaSLen Brown 		/*
2230103a8feaSLen Brown 		 * Non-Stop TSC is advertised by CPUID.EAX=0x80000007: EDX.bit8
2231103a8feaSLen Brown 		 * this check is valid for both Intel and AMD
2232103a8feaSLen Brown 		 */
22332b92865eSJosh Triplett 		__get_cpuid(0x80000007, &eax, &ebx, &ecx, &edx);
22348209e054SThomas Renninger 		has_invariant_tsc = edx & (1 << 8);
2235d7899447SLen Brown 	}
2236103a8feaSLen Brown 
2237103a8feaSLen Brown 	/*
2238103a8feaSLen Brown 	 * APERF/MPERF is advertised by CPUID.EAX=0x6: ECX.bit0
2239103a8feaSLen Brown 	 * this check is valid for both Intel and AMD
2240103a8feaSLen Brown 	 */
2241103a8feaSLen Brown 
22422b92865eSJosh Triplett 	__get_cpuid(0x6, &eax, &ebx, &ecx, &edx);
22438209e054SThomas Renninger 	has_aperf = ecx & (1 << 0);
2244889facbeSLen Brown 	do_dts = eax & (1 << 0);
2245889facbeSLen Brown 	do_ptm = eax & (1 << 6);
2246889facbeSLen Brown 	has_epb = ecx & (1 << 3);
2247889facbeSLen Brown 
2248889facbeSLen Brown 	if (verbose)
2249*a729617cSLen Brown 		fprintf(stderr, "CPUID(6): %sAPERF, %sDTS, %sPTM, %sEPB\n",
2250*a729617cSLen Brown 			has_aperf ? "" : "No ",
2251*a729617cSLen Brown 			do_dts ? "" : "No ",
2252*a729617cSLen Brown 			do_ptm ? "" : "No ",
2253*a729617cSLen Brown 			has_epb ? "" : "No ");
2254103a8feaSLen Brown 
2255d7899447SLen Brown 	do_nhm_platform_info = do_nhm_cstates = do_smi = has_nhm_msrs(family, model);
2256d7899447SLen Brown 	do_snb_cstates = has_snb_msrs(family, model);
2257d7899447SLen Brown 	do_c8_c9_c10 = has_hsw_msrs(family, model);
2258144b44b1SLen Brown 	do_slm_cstates = is_slm(family, model);
2259103a8feaSLen Brown 	bclk = discover_bclk(family, model);
2260103a8feaSLen Brown 
2261d7899447SLen Brown 	do_nhm_turbo_ratio_limit = has_nhm_turbo_ratio_limit(family, model);
22626574a5d5SLen Brown 	do_ivt_turbo_ratio_limit = has_ivt_turbo_ratio_limit(family, model);
2263889facbeSLen Brown 	rapl_probe(family, model);
22643a9a941dSLen Brown 	perf_limit_reasons_probe(family, model);
2265889facbeSLen Brown 
2266889facbeSLen Brown 	return;
2267103a8feaSLen Brown }
2268103a8feaSLen Brown 
2269103a8feaSLen Brown 
2270103a8feaSLen Brown void usage()
2271103a8feaSLen Brown {
2272f591c38bSAndy Shevchenko 	errx(1, "%s: [-v][-R][-T][-p|-P|-S][-c MSR#][-C MSR#][-m MSR#][-M MSR#][-i interval_sec | command ...]\n",
2273103a8feaSLen Brown 	     progname);
2274103a8feaSLen Brown }
2275103a8feaSLen Brown 
2276103a8feaSLen Brown 
2277103a8feaSLen Brown /*
2278103a8feaSLen Brown  * in /dev/cpu/ return success for names that are numbers
2279103a8feaSLen Brown  * ie. filter out ".", "..", "microcode".
2280103a8feaSLen Brown  */
2281103a8feaSLen Brown int dir_filter(const struct dirent *dirp)
2282103a8feaSLen Brown {
2283103a8feaSLen Brown 	if (isdigit(dirp->d_name[0]))
2284103a8feaSLen Brown 		return 1;
2285103a8feaSLen Brown 	else
2286103a8feaSLen Brown 		return 0;
2287103a8feaSLen Brown }
2288103a8feaSLen Brown 
2289103a8feaSLen Brown int open_dev_cpu_msr(int dummy1)
2290103a8feaSLen Brown {
2291103a8feaSLen Brown 	return 0;
2292103a8feaSLen Brown }
2293103a8feaSLen Brown 
2294c98d5d94SLen Brown void topology_probe()
2295c98d5d94SLen Brown {
2296c98d5d94SLen Brown 	int i;
2297c98d5d94SLen Brown 	int max_core_id = 0;
2298c98d5d94SLen Brown 	int max_package_id = 0;
2299c98d5d94SLen Brown 	int max_siblings = 0;
2300c98d5d94SLen Brown 	struct cpu_topology {
2301c98d5d94SLen Brown 		int core_id;
2302c98d5d94SLen Brown 		int physical_package_id;
2303c98d5d94SLen Brown 	} *cpus;
2304c98d5d94SLen Brown 
2305c98d5d94SLen Brown 	/* Initialize num_cpus, max_cpu_num */
2306c98d5d94SLen Brown 	topo.num_cpus = 0;
2307c98d5d94SLen Brown 	topo.max_cpu_num = 0;
2308c98d5d94SLen Brown 	for_all_proc_cpus(count_cpus);
2309c98d5d94SLen Brown 	if (!summary_only && topo.num_cpus > 1)
2310c98d5d94SLen Brown 		show_cpu = 1;
2311c98d5d94SLen Brown 
2312c98d5d94SLen Brown 	if (verbose > 1)
2313c98d5d94SLen Brown 		fprintf(stderr, "num_cpus %d max_cpu_num %d\n", topo.num_cpus, topo.max_cpu_num);
2314c98d5d94SLen Brown 
2315c98d5d94SLen Brown 	cpus = calloc(1, (topo.max_cpu_num  + 1) * sizeof(struct cpu_topology));
2316b2c95d90SJosh Triplett 	if (cpus == NULL)
2317b2c95d90SJosh Triplett 		err(1, "calloc cpus");
2318c98d5d94SLen Brown 
2319c98d5d94SLen Brown 	/*
2320c98d5d94SLen Brown 	 * Allocate and initialize cpu_present_set
2321c98d5d94SLen Brown 	 */
2322c98d5d94SLen Brown 	cpu_present_set = CPU_ALLOC((topo.max_cpu_num + 1));
2323b2c95d90SJosh Triplett 	if (cpu_present_set == NULL)
2324b2c95d90SJosh Triplett 		err(3, "CPU_ALLOC");
2325c98d5d94SLen Brown 	cpu_present_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
2326c98d5d94SLen Brown 	CPU_ZERO_S(cpu_present_setsize, cpu_present_set);
2327c98d5d94SLen Brown 	for_all_proc_cpus(mark_cpu_present);
2328c98d5d94SLen Brown 
2329c98d5d94SLen Brown 	/*
2330c98d5d94SLen Brown 	 * Allocate and initialize cpu_affinity_set
2331c98d5d94SLen Brown 	 */
2332c98d5d94SLen Brown 	cpu_affinity_set = CPU_ALLOC((topo.max_cpu_num + 1));
2333b2c95d90SJosh Triplett 	if (cpu_affinity_set == NULL)
2334b2c95d90SJosh Triplett 		err(3, "CPU_ALLOC");
2335c98d5d94SLen Brown 	cpu_affinity_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
2336c98d5d94SLen Brown 	CPU_ZERO_S(cpu_affinity_setsize, cpu_affinity_set);
2337c98d5d94SLen Brown 
2338c98d5d94SLen Brown 
2339c98d5d94SLen Brown 	/*
2340c98d5d94SLen Brown 	 * For online cpus
2341c98d5d94SLen Brown 	 * find max_core_id, max_package_id
2342c98d5d94SLen Brown 	 */
2343c98d5d94SLen Brown 	for (i = 0; i <= topo.max_cpu_num; ++i) {
2344c98d5d94SLen Brown 		int siblings;
2345c98d5d94SLen Brown 
2346c98d5d94SLen Brown 		if (cpu_is_not_present(i)) {
2347c98d5d94SLen Brown 			if (verbose > 1)
2348c98d5d94SLen Brown 				fprintf(stderr, "cpu%d NOT PRESENT\n", i);
2349c98d5d94SLen Brown 			continue;
2350c98d5d94SLen Brown 		}
2351c98d5d94SLen Brown 		cpus[i].core_id = get_core_id(i);
2352c98d5d94SLen Brown 		if (cpus[i].core_id > max_core_id)
2353c98d5d94SLen Brown 			max_core_id = cpus[i].core_id;
2354c98d5d94SLen Brown 
2355c98d5d94SLen Brown 		cpus[i].physical_package_id = get_physical_package_id(i);
2356c98d5d94SLen Brown 		if (cpus[i].physical_package_id > max_package_id)
2357c98d5d94SLen Brown 			max_package_id = cpus[i].physical_package_id;
2358c98d5d94SLen Brown 
2359c98d5d94SLen Brown 		siblings = get_num_ht_siblings(i);
2360c98d5d94SLen Brown 		if (siblings > max_siblings)
2361c98d5d94SLen Brown 			max_siblings = siblings;
2362c98d5d94SLen Brown 		if (verbose > 1)
2363c98d5d94SLen Brown 			fprintf(stderr, "cpu %d pkg %d core %d\n",
2364c98d5d94SLen Brown 				i, cpus[i].physical_package_id, cpus[i].core_id);
2365c98d5d94SLen Brown 	}
2366c98d5d94SLen Brown 	topo.num_cores_per_pkg = max_core_id + 1;
2367c98d5d94SLen Brown 	if (verbose > 1)
2368c98d5d94SLen Brown 		fprintf(stderr, "max_core_id %d, sizing for %d cores per package\n",
2369c98d5d94SLen Brown 			max_core_id, topo.num_cores_per_pkg);
2370c98d5d94SLen Brown 	if (!summary_only && topo.num_cores_per_pkg > 1)
2371c98d5d94SLen Brown 		show_core = 1;
2372c98d5d94SLen Brown 
2373c98d5d94SLen Brown 	topo.num_packages = max_package_id + 1;
2374c98d5d94SLen Brown 	if (verbose > 1)
2375c98d5d94SLen Brown 		fprintf(stderr, "max_package_id %d, sizing for %d packages\n",
2376c98d5d94SLen Brown 			max_package_id, topo.num_packages);
2377c98d5d94SLen Brown 	if (!summary_only && topo.num_packages > 1)
2378c98d5d94SLen Brown 		show_pkg = 1;
2379c98d5d94SLen Brown 
2380c98d5d94SLen Brown 	topo.num_threads_per_core = max_siblings;
2381c98d5d94SLen Brown 	if (verbose > 1)
2382c98d5d94SLen Brown 		fprintf(stderr, "max_siblings %d\n", max_siblings);
2383c98d5d94SLen Brown 
2384c98d5d94SLen Brown 	free(cpus);
2385c98d5d94SLen Brown }
2386c98d5d94SLen Brown 
2387c98d5d94SLen Brown void
2388c98d5d94SLen Brown allocate_counters(struct thread_data **t, struct core_data **c, struct pkg_data **p)
2389c98d5d94SLen Brown {
2390c98d5d94SLen Brown 	int i;
2391c98d5d94SLen Brown 
2392c98d5d94SLen Brown 	*t = calloc(topo.num_threads_per_core * topo.num_cores_per_pkg *
2393c98d5d94SLen Brown 		topo.num_packages, sizeof(struct thread_data));
2394c98d5d94SLen Brown 	if (*t == NULL)
2395c98d5d94SLen Brown 		goto error;
2396c98d5d94SLen Brown 
2397c98d5d94SLen Brown 	for (i = 0; i < topo.num_threads_per_core *
2398c98d5d94SLen Brown 		topo.num_cores_per_pkg * topo.num_packages; i++)
2399c98d5d94SLen Brown 		(*t)[i].cpu_id = -1;
2400c98d5d94SLen Brown 
2401c98d5d94SLen Brown 	*c = calloc(topo.num_cores_per_pkg * topo.num_packages,
2402c98d5d94SLen Brown 		sizeof(struct core_data));
2403c98d5d94SLen Brown 	if (*c == NULL)
2404c98d5d94SLen Brown 		goto error;
2405c98d5d94SLen Brown 
2406c98d5d94SLen Brown 	for (i = 0; i < topo.num_cores_per_pkg * topo.num_packages; i++)
2407c98d5d94SLen Brown 		(*c)[i].core_id = -1;
2408c98d5d94SLen Brown 
2409c98d5d94SLen Brown 	*p = calloc(topo.num_packages, sizeof(struct pkg_data));
2410c98d5d94SLen Brown 	if (*p == NULL)
2411c98d5d94SLen Brown 		goto error;
2412c98d5d94SLen Brown 
2413c98d5d94SLen Brown 	for (i = 0; i < topo.num_packages; i++)
2414c98d5d94SLen Brown 		(*p)[i].package_id = i;
2415c98d5d94SLen Brown 
2416c98d5d94SLen Brown 	return;
2417c98d5d94SLen Brown error:
2418b2c95d90SJosh Triplett 	err(1, "calloc counters");
2419c98d5d94SLen Brown }
2420c98d5d94SLen Brown /*
2421c98d5d94SLen Brown  * init_counter()
2422c98d5d94SLen Brown  *
2423c98d5d94SLen Brown  * set cpu_id, core_num, pkg_num
2424c98d5d94SLen Brown  * set FIRST_THREAD_IN_CORE and FIRST_CORE_IN_PACKAGE
2425c98d5d94SLen Brown  *
2426c98d5d94SLen Brown  * increment topo.num_cores when 1st core in pkg seen
2427c98d5d94SLen Brown  */
2428c98d5d94SLen Brown void init_counter(struct thread_data *thread_base, struct core_data *core_base,
2429c98d5d94SLen Brown 	struct pkg_data *pkg_base, int thread_num, int core_num,
2430c98d5d94SLen Brown 	int pkg_num, int cpu_id)
2431c98d5d94SLen Brown {
2432c98d5d94SLen Brown 	struct thread_data *t;
2433c98d5d94SLen Brown 	struct core_data *c;
2434c98d5d94SLen Brown 	struct pkg_data *p;
2435c98d5d94SLen Brown 
2436c98d5d94SLen Brown 	t = GET_THREAD(thread_base, thread_num, core_num, pkg_num);
2437c98d5d94SLen Brown 	c = GET_CORE(core_base, core_num, pkg_num);
2438c98d5d94SLen Brown 	p = GET_PKG(pkg_base, pkg_num);
2439c98d5d94SLen Brown 
2440c98d5d94SLen Brown 	t->cpu_id = cpu_id;
2441c98d5d94SLen Brown 	if (thread_num == 0) {
2442c98d5d94SLen Brown 		t->flags |= CPU_IS_FIRST_THREAD_IN_CORE;
2443c98d5d94SLen Brown 		if (cpu_is_first_core_in_package(cpu_id))
2444c98d5d94SLen Brown 			t->flags |= CPU_IS_FIRST_CORE_IN_PACKAGE;
2445c98d5d94SLen Brown 	}
2446c98d5d94SLen Brown 
2447c98d5d94SLen Brown 	c->core_id = core_num;
2448c98d5d94SLen Brown 	p->package_id = pkg_num;
2449c98d5d94SLen Brown }
2450c98d5d94SLen Brown 
2451c98d5d94SLen Brown 
2452c98d5d94SLen Brown int initialize_counters(int cpu_id)
2453c98d5d94SLen Brown {
2454c98d5d94SLen Brown 	int my_thread_id, my_core_id, my_package_id;
2455c98d5d94SLen Brown 
2456c98d5d94SLen Brown 	my_package_id = get_physical_package_id(cpu_id);
2457c98d5d94SLen Brown 	my_core_id = get_core_id(cpu_id);
2458c98d5d94SLen Brown 
2459c98d5d94SLen Brown 	if (cpu_is_first_sibling_in_core(cpu_id)) {
2460c98d5d94SLen Brown 		my_thread_id = 0;
2461c98d5d94SLen Brown 		topo.num_cores++;
2462c98d5d94SLen Brown 	} else {
2463c98d5d94SLen Brown 		my_thread_id = 1;
2464c98d5d94SLen Brown 	}
2465c98d5d94SLen Brown 
2466c98d5d94SLen Brown 	init_counter(EVEN_COUNTERS, my_thread_id, my_core_id, my_package_id, cpu_id);
2467c98d5d94SLen Brown 	init_counter(ODD_COUNTERS, my_thread_id, my_core_id, my_package_id, cpu_id);
2468c98d5d94SLen Brown 	return 0;
2469c98d5d94SLen Brown }
2470c98d5d94SLen Brown 
2471c98d5d94SLen Brown void allocate_output_buffer()
2472c98d5d94SLen Brown {
24733b4d5c7fSAndy Shevchenko 	output_buffer = calloc(1, (1 + topo.num_cpus) * 1024);
2474c98d5d94SLen Brown 	outp = output_buffer;
2475b2c95d90SJosh Triplett 	if (outp == NULL)
2476b2c95d90SJosh Triplett 		err(-1, "calloc output buffer");
2477c98d5d94SLen Brown }
2478c98d5d94SLen Brown 
2479c98d5d94SLen Brown void setup_all_buffers(void)
2480c98d5d94SLen Brown {
2481c98d5d94SLen Brown 	topology_probe();
2482c98d5d94SLen Brown 	allocate_counters(&thread_even, &core_even, &package_even);
2483c98d5d94SLen Brown 	allocate_counters(&thread_odd, &core_odd, &package_odd);
2484c98d5d94SLen Brown 	allocate_output_buffer();
2485c98d5d94SLen Brown 	for_all_proc_cpus(initialize_counters);
2486c98d5d94SLen Brown }
24873b4d5c7fSAndy Shevchenko 
2488103a8feaSLen Brown void turbostat_init()
2489103a8feaSLen Brown {
2490103a8feaSLen Brown 	check_dev_msr();
249198481e79SLen Brown 	check_permissions();
249298481e79SLen Brown 	check_cpuid();
2493103a8feaSLen Brown 
2494c98d5d94SLen Brown 	setup_all_buffers();
2495103a8feaSLen Brown 
2496103a8feaSLen Brown 	if (verbose)
2497c98d5d94SLen Brown 		print_verbose_header();
2498889facbeSLen Brown 
2499889facbeSLen Brown 	if (verbose)
2500889facbeSLen Brown 		for_all_cpus(print_epb, ODD_COUNTERS);
2501889facbeSLen Brown 
2502889facbeSLen Brown 	if (verbose)
25033a9a941dSLen Brown 		for_all_cpus(print_perf_limit, ODD_COUNTERS);
25043a9a941dSLen Brown 
25053a9a941dSLen Brown 	if (verbose)
2506889facbeSLen Brown 		for_all_cpus(print_rapl, ODD_COUNTERS);
2507889facbeSLen Brown 
2508889facbeSLen Brown 	for_all_cpus(set_temperature_target, ODD_COUNTERS);
2509889facbeSLen Brown 
2510889facbeSLen Brown 	if (verbose)
2511889facbeSLen Brown 		for_all_cpus(print_thermal, ODD_COUNTERS);
2512103a8feaSLen Brown }
2513103a8feaSLen Brown 
2514103a8feaSLen Brown int fork_it(char **argv)
2515103a8feaSLen Brown {
2516103a8feaSLen Brown 	pid_t child_pid;
2517d91bb17cSLen Brown 	int status;
2518d15cf7c1SLen Brown 
2519d91bb17cSLen Brown 	status = for_all_cpus(get_counters, EVEN_COUNTERS);
2520d91bb17cSLen Brown 	if (status)
2521d91bb17cSLen Brown 		exit(status);
2522d15cf7c1SLen Brown 	/* clear affinity side-effect of get_counters() */
2523d15cf7c1SLen Brown 	sched_setaffinity(0, cpu_present_setsize, cpu_present_set);
2524103a8feaSLen Brown 	gettimeofday(&tv_even, (struct timezone *)NULL);
2525103a8feaSLen Brown 
2526103a8feaSLen Brown 	child_pid = fork();
2527103a8feaSLen Brown 	if (!child_pid) {
2528103a8feaSLen Brown 		/* child */
2529103a8feaSLen Brown 		execvp(argv[0], argv);
2530103a8feaSLen Brown 	} else {
2531103a8feaSLen Brown 
2532103a8feaSLen Brown 		/* parent */
2533b2c95d90SJosh Triplett 		if (child_pid == -1)
2534b2c95d90SJosh Triplett 			err(1, "fork");
2535103a8feaSLen Brown 
2536103a8feaSLen Brown 		signal(SIGINT, SIG_IGN);
2537103a8feaSLen Brown 		signal(SIGQUIT, SIG_IGN);
2538b2c95d90SJosh Triplett 		if (waitpid(child_pid, &status, 0) == -1)
2539b2c95d90SJosh Triplett 			err(status, "waitpid");
2540103a8feaSLen Brown 	}
2541c98d5d94SLen Brown 	/*
2542c98d5d94SLen Brown 	 * n.b. fork_it() does not check for errors from for_all_cpus()
2543c98d5d94SLen Brown 	 * because re-starting is problematic when forking
2544c98d5d94SLen Brown 	 */
2545c98d5d94SLen Brown 	for_all_cpus(get_counters, ODD_COUNTERS);
2546103a8feaSLen Brown 	gettimeofday(&tv_odd, (struct timezone *)NULL);
2547103a8feaSLen Brown 	timersub(&tv_odd, &tv_even, &tv_delta);
2548c98d5d94SLen Brown 	for_all_cpus_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS);
2549c98d5d94SLen Brown 	compute_average(EVEN_COUNTERS);
2550c98d5d94SLen Brown 	format_all_counters(EVEN_COUNTERS);
2551c98d5d94SLen Brown 	flush_stderr();
2552103a8feaSLen Brown 
25536eab04a8SJustin P. Mattock 	fprintf(stderr, "%.6f sec\n", tv_delta.tv_sec + tv_delta.tv_usec/1000000.0);
2554103a8feaSLen Brown 
2555d91bb17cSLen Brown 	return status;
2556103a8feaSLen Brown }
2557103a8feaSLen Brown 
25583b4d5c7fSAndy Shevchenko int get_and_dump_counters(void)
25593b4d5c7fSAndy Shevchenko {
25603b4d5c7fSAndy Shevchenko 	int status;
25613b4d5c7fSAndy Shevchenko 
25623b4d5c7fSAndy Shevchenko 	status = for_all_cpus(get_counters, ODD_COUNTERS);
25633b4d5c7fSAndy Shevchenko 	if (status)
25643b4d5c7fSAndy Shevchenko 		return status;
25653b4d5c7fSAndy Shevchenko 
25663b4d5c7fSAndy Shevchenko 	status = for_all_cpus(dump_counters, ODD_COUNTERS);
25673b4d5c7fSAndy Shevchenko 	if (status)
25683b4d5c7fSAndy Shevchenko 		return status;
25693b4d5c7fSAndy Shevchenko 
25703b4d5c7fSAndy Shevchenko 	flush_stdout();
25713b4d5c7fSAndy Shevchenko 
25723b4d5c7fSAndy Shevchenko 	return status;
25733b4d5c7fSAndy Shevchenko }
25743b4d5c7fSAndy Shevchenko 
2575103a8feaSLen Brown void cmdline(int argc, char **argv)
2576103a8feaSLen Brown {
2577103a8feaSLen Brown 	int opt;
2578103a8feaSLen Brown 
2579103a8feaSLen Brown 	progname = argv[0];
2580103a8feaSLen Brown 
25813b4d5c7fSAndy Shevchenko 	while ((opt = getopt(argc, argv, "+pPsSvi:c:C:m:M:RJT:")) != -1) {
2582103a8feaSLen Brown 		switch (opt) {
2583f9240813SLen Brown 		case 'p':
2584c98d5d94SLen Brown 			show_core_only++;
2585c98d5d94SLen Brown 			break;
2586f9240813SLen Brown 		case 'P':
2587c98d5d94SLen Brown 			show_pkg_only++;
2588c98d5d94SLen Brown 			break;
25893b4d5c7fSAndy Shevchenko 		case 's':
25903b4d5c7fSAndy Shevchenko 			dump_only++;
25913b4d5c7fSAndy Shevchenko 			break;
2592f9240813SLen Brown 		case 'S':
2593e23da037SLen Brown 			summary_only++;
2594e23da037SLen Brown 			break;
2595103a8feaSLen Brown 		case 'v':
2596103a8feaSLen Brown 			verbose++;
2597103a8feaSLen Brown 			break;
2598103a8feaSLen Brown 		case 'i':
2599103a8feaSLen Brown 			interval_sec = atoi(optarg);
2600103a8feaSLen Brown 			break;
2601f9240813SLen Brown 		case 'c':
26028e180f3cSLen Brown 			sscanf(optarg, "%x", &extra_delta_offset32);
26038e180f3cSLen Brown 			break;
2604f9240813SLen Brown 		case 'C':
26058e180f3cSLen Brown 			sscanf(optarg, "%x", &extra_delta_offset64);
26068e180f3cSLen Brown 			break;
26072f32edf1SLen Brown 		case 'm':
26082f32edf1SLen Brown 			sscanf(optarg, "%x", &extra_msr_offset32);
26092f32edf1SLen Brown 			break;
26102f32edf1SLen Brown 		case 'M':
26112f32edf1SLen Brown 			sscanf(optarg, "%x", &extra_msr_offset64);
2612103a8feaSLen Brown 			break;
2613889facbeSLen Brown 		case 'R':
2614889facbeSLen Brown 			rapl_verbose++;
2615889facbeSLen Brown 			break;
2616889facbeSLen Brown 		case 'T':
2617889facbeSLen Brown 			tcc_activation_temp_override = atoi(optarg);
2618889facbeSLen Brown 			break;
26195c56be9aSDirk Brandewie 		case 'J':
26205c56be9aSDirk Brandewie 			rapl_joules++;
26215c56be9aSDirk Brandewie 			break;
26225c56be9aSDirk Brandewie 
2623103a8feaSLen Brown 		default:
2624103a8feaSLen Brown 			usage();
2625103a8feaSLen Brown 		}
2626103a8feaSLen Brown 	}
2627103a8feaSLen Brown }
2628103a8feaSLen Brown 
2629103a8feaSLen Brown int main(int argc, char **argv)
2630103a8feaSLen Brown {
2631103a8feaSLen Brown 	cmdline(argc, argv);
2632103a8feaSLen Brown 
2633889facbeSLen Brown 	if (verbose)
2634*a729617cSLen Brown 		fprintf(stderr, "turbostat v3.9 23-Jan, 2015"
2635103a8feaSLen Brown 			" - Len Brown <lenb@kernel.org>\n");
2636103a8feaSLen Brown 
2637103a8feaSLen Brown 	turbostat_init();
2638103a8feaSLen Brown 
26393b4d5c7fSAndy Shevchenko 	/* dump counters and exit */
26403b4d5c7fSAndy Shevchenko 	if (dump_only)
26413b4d5c7fSAndy Shevchenko 		return get_and_dump_counters();
26423b4d5c7fSAndy Shevchenko 
2643103a8feaSLen Brown 	/*
2644103a8feaSLen Brown 	 * if any params left, it must be a command to fork
2645103a8feaSLen Brown 	 */
2646103a8feaSLen Brown 	if (argc - optind)
2647103a8feaSLen Brown 		return fork_it(argv + optind);
2648103a8feaSLen Brown 	else
2649103a8feaSLen Brown 		turbostat_loop();
2650103a8feaSLen Brown 
2651103a8feaSLen Brown 	return 0;
2652103a8feaSLen Brown }
2653